abstract.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 ABSTRACT_H_INCLUDED
#define ABSTRACT_H_INCLUDED

#include <iostream>
#include <string>
#include <sstream>
#include <cassert>

#include <memory>
#include <functional>
#include <optional>

#include <vector>
#include <initializer_list>
#include <map>
#include <set>

#include <thread>
#include <mutex>

#include "allocator.h"
#include "support.h"
#include "error.h"
#include "typedef.h"
#include "enum.h"
#include "evaluation.h"
#include "std_shared_ptr_inheritance.h"
#ifdef DEBUG
#include "alloc_monitor.h"
#endif

// Forward declaration of Index TensorParent 
// and IndexStructure classes (indicial.h)
namespace csl {

class Index;
class IndexStructure;
class Space;
class AbstractParent;
class TensorParent;
class Equation;
class ContractionChain;
class LibDependency;

#ifdef DEBUG
class Abstract: public __alloc_monitor {
#else

class Abstract{
#endif

    public:

    /*************************************************/
    // Constructors and destructors                  //
    /*************************************************/

#ifdef DEBUG
    Abstract(): __alloc_monitor() {};
#else
    Abstract() {};
#endif

    virtual ~Abstract() {}

    Expr self();
                                                       

    /*************************************************/
    // Utils, common to all Abstract                 //
    /*************************************************/

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

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

    static std::string regularName(std::string const &name);
    static std::string regularName(std::string_view name);
    static std::string regularLiteral(std::string const &name);
    static std::string regularLiteral(std::string_view name);

    virtual void printProp(std::ostream& fout = std::cout) const;

    void printExplicit(int mode=0) const;

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

    virtual std::vector<Parent> getSubSymbols() const = 0;

    virtual LibDependency getLibDependency() const;

    virtual size_t memoryOverhead() const;
                                                       

    /*************************************************/
    // Common access functions for all Abstracts     //
    /*************************************************/

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

    virtual std::string const &getLatexName() const; 
    
    virtual bool getCommutable() const; 

    virtual bool getElementary() const;

    virtual bool getAllDependencies() const;

    virtual csl::PrimaryType getPrimaryType() const = 0; 

    virtual csl::Type getType() const = 0;

    virtual int getDim() const;

    virtual bool isBuildingBlock() const;

    virtual int getOrderOf(Expr_info expr) const;

    virtual bool isArbitrary() const;

    virtual bool isIndexed() const;

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

    virtual bool isReal() const;

    virtual bool isPurelyImaginary() const;

    virtual bool isComplexConjugate() const;

    virtual bool isHermitianConjugate() const;

    virtual csl::ComplexProperty getComplexProperty() const;

    virtual void setComplexProperty(csl::ComplexProperty prop);

    virtual void setConjugated(bool t_conjugated);


    /*************************************************/
    // Access functions for specializations          //
    /*************************************************/

    // Numerical- and Literal types

    virtual bool isInteger() const;
    virtual bool getValued() const;
    virtual long double getValue() const;

    virtual long double getDeltaPlus() const;

    virtual long double getDeltaMinus() const;

    // Class IntFraction

    virtual long long int getNum() const; 
    virtual long long int getDenom() const; 

    // (Multiple) argument(s) functions

    virtual int getNArgs(int axis=0) const;

    virtual size_t size() const;

    virtual bool empty() const;

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

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

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

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

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

    virtual Expr& getArgument(int iArg=0); 

    virtual Expr const &getArgument(const std::vector<int>& indices) const;

    virtual Expr& getArgument(const std::vector<int>& indices);

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

    // Derivative, Integral, Polynomial, Commutator

    virtual Expr getVariable() const;

    virtual int getOrder() const;

    virtual int getSign() const;

    virtual bool isAnOperator() const;

    virtual bool isEmpty() const;

    virtual bool operatorAppliesOn(Expr_info expr) const;

    virtual Expr getOperand() const;

    // Vectorial-type expressions

    virtual std::vector<int> getShape() const;

    // Integral

    virtual Expr getInfBoundary() const;

    virtual Expr getSupBoundary() const;

    virtual void setSupBoundary(Expr const &t_inf);

    virtual void setInfBoundary(Expr const &t_inf);

    // Indicial-type expressions
    //
   
    virtual int getNIndices() const;

    virtual Index getIndex(int i=0) const;

    virtual void resetIndexStructure();

    virtual IndexStructure getIndexStructure() const;

    IndexStructure getIndexStructure(csl::Space const *space) const;

    virtual const IndexStructure& getIndexStructureView() const;

    virtual IndexStructure& getIndexStructureView();

    virtual IndexStructure getFreeIndexStructure() const;

    virtual Parent getParent() const;

    virtual Parent_info getParent_info() const;

    virtual Tensor getPoint() const;

    virtual int getNContractedPairs() const;

    virtual csl::vector_expr getPermutations(bool optimize = true) const;

    virtual std::set<std::pair<int,int> > getContractedPair() const;

    // Copy functions for derivated classes 
    // (to reimplement)

    Expr copy() const;

    virtual unique_Expr copy_unique() const = 0;

    virtual Expr deepCopy() const;

    virtual Expr refresh() const;
    
    virtual Expr deepRefresh() const;
                                                       
                                                       

    /*************************************************/
    // Common modifiers for all Abstracts            //
    /*************************************************/

    virtual void setName(const std::string& t_name); 

    virtual void setCommutable(bool t_commutable); 

    virtual void addProperty(Equation* property);

    virtual void removeProperty(Equation* property);

                                                       
                                                       

    /*************************************************/
    // Modifiers for specializations                 //
    /*************************************************/

    // Numerical- and Literal- types
    
    virtual void setValue(long double t_value);

    virtual void setValue(Expr const &t_value);

    // Variable

    virtual void setElementary(bool t_elementary);

    virtual void setAllDependencies(bool t_allDependencies);

    virtual void addDependency(Expr const& expr);

    virtual void removeDependency(Expr const& expr);

    // (Multi) argument(s) functions

    virtual void setArgument(const Expr& expr, int iArg=0);

    virtual void setArgument(const Expr& expr,
                             const std::vector<int>& indices);

    virtual void setEmpty(bool t_empty);

    virtual void setOperand(const Expr& operand);

    virtual void setOperandPrivate(const Expr& operand, bool leaveEmpty);

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

    virtual void setVariable(Expr const &t_variable);

    // Sum and Prod

     virtual void insert(const Expr& expr, bool side=1);

    // Indicial types
    
     virtual void setParent(const Parent& t_parent);

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

     virtual std::optional<Expr> replaceIndices(
             std::vector<Index> const &indexToReplace,
             std::vector<Index> const &newIndex,
             bool         refresh = true,
             bool         flipped = false) const;

     virtual void replaceIndexInPlace(
         Index const &oldIndex,
         Index const &newIndex);

     std::optional<Expr> contractIndex(const Index& index) const;

     csl::vector_expr breakSpace(
             const Space*                     brokenSpace,
             const std::vector<const Space*>& newSpace) const;

     virtual csl::vector_expr breakSpace(
             const Space*                     brokenSpace,
             const std::vector<const Space*>& newSpace,
             const std::vector<std::string>&  indexNames) const;


    virtual void setIndexStructure(const IndexStructure& t_index);

    virtual void setPoint(const Tensor& t_point);

    virtual void setFullySymmetric();

    virtual void setFullyAntiSymmetric();

    virtual void addSymmetry(int i1, int i2);

    virtual void addAntiSymmetry(int i1, int i2);

    virtual int permut(int i1, int i2);

                                                       
                                                       

    /*************************************************/
    // Getting properties that need calculation      //
    /*************************************************/

    // Useful functions in factorization and
    // for making canonical expressions (basic 
    // simplifications).

    virtual Expr getNumericalFactor() const;

    virtual int getNFactor() const;

    virtual csl::vector_expr getFactors() const;

    virtual std::optional<Expr> getTerm() const;

    virtual void getExponents(
            std::vector<Expr> const &factors,
            std::vector<Expr>       &exponents
            ) const;

    // Checking matching of different indicial 
    // expressions in calculations.

    virtual bool checkIndexStructure(const std::vector<Index>& t_index) const;

    virtual bool checkIndexStructure(const std::initializer_list<Index>& index) const;

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

    bool compareWithDummy(Expr_info expr,
            bool keepAllCosntraints = false) const;
    
                                                       

    /*************************************************/
    // Getting properties depending on an expr //
    /*************************************************/

    virtual int getParity(Expr_info t_variable) const;

    virtual bool askTerm(Expr_info expr, bool exact=false) const;

    virtual bool dependsOn(Expr_info expr) const;

    virtual bool dependsOn(Parent_info parent) const;

    virtual bool dependsExplicitlyOn(Expr_info expr) const;

    virtual bool dependsExplicitlyOn(Parent_info parent) const;

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

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

    virtual int isPolynomial(Expr_info expr) const;

    virtual bool matchShape(Expr_info expr, bool exact=false) const;

    virtual bool hasContractionProperty(Expr_info B) const;

    virtual bool hasChainContractionProperty() const;

    virtual std::vector<ContractionChain> getContractionProperties() const;

    virtual Expr contraction(Expr_info B) const;

    virtual Expr contraction(const csl::vector_expr& chain) const;




    /*************************************************/
    // Members that return new exprs                 //
    // results of specific calculations              //
    // COMMON TO ALL ABSTRACTS PART                  //
    /*************************************************/

    virtual long double evaluateScalar() const; 

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

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

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

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

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

    virtual Expr suppressTerm(Expr_info expr) const;

    virtual std::optional<Expr> suppressExponent(
            Expr const & factor,
            Expr const &exponent
            ) const;

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

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

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

    virtual Expr getImaginaryPart() const;

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

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

    virtual Expr& applySelfStructureOn(Expr& expr) const;

    virtual std::optional<Expr> getTransposed(
            const Space* space,
            bool         applyProp = true) const;

    virtual std::optional<Expr> getTransposed(
            const std::vector<const Space*>& spaces,
            bool                             applyProp = true) const;

    virtual std::optional<Expr> getHermitianConjugate(
            const Space* space) const;

    virtual std::optional<Expr> getHermitianConjugate(
            const std::vector<const Space*>& spaces) const;

    virtual std::optional<Expr> getPolynomialTerm(
            Expr_info t_variable, int order) const;

    virtual csl::vector_expr getAlternateForms() const;

    virtual Expr applyOperator(const Expr& operand, 
                               bool        leaveEmpty=false) const;




    /*************************************************/
    // Members that return new exprs                 //
    // results of specific calculations              //
    // SPECIFIC TO SOME ABSTRACTS PART               //
    /*************************************************/

    // Numerical- Polynomial- and Vectorial-types
    
    virtual Expr addition_own(const Expr& expr) const;

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

    virtual Expr division_own(const Expr& expr) const;

    virtual Expr exponentiation_own(const Expr& expr) const;

    // Polynomial type

    virtual Expr getRegularExpression() const;

    // Vectorial type

    virtual Expr tensordot(const Expr& expr) const;

    virtual Expr dot(const Expr& expr) const;

    virtual Expr getSum() const;

    virtual Expr getProduct() const; 

    virtual Expr getVectorialModulus() const;

    virtual Expr getSubVectorial(int iExcept) const;

    virtual Expr getSubVectorial(int iExcept, int jExcept) const;

    virtual Expr getSubVectorial(const std::vector<int>& exceptions) const;

    virtual Expr getSubVectorial(
            const std::vector<std::vector<int>>& keepIndices) const;

    virtual Expr getSubVectorial(
            std::vector<std::vector<int>>::const_iterator begin,
            std::vector<std::vector<int>>::const_iterator end) const;

    virtual Expr determinant() const;

    virtual Expr trace() const;

    virtual Expr trace(int axis1, int axis2) const;

    virtual Expr transpose() const;

    virtual Expr hermitian() const;

    virtual Expr symmetrise() const;

    virtual Expr antisymmetrise() const;

    virtual Expr inverseMatrix() const;

    // Indicial

    virtual Expr getCanonicalPermutation() const;


    virtual Expr applyDiracDelta(const Expr&, const Expr&) const;


    /*************************************************/
    // Operators                                     //
    /*************************************************/

    virtual void operator=(double t_value);

    virtual bool operator==(int t_value) const; 
    virtual bool operator==(double t_value) const; 
    virtual bool operator!=(int t_value) const; 
    virtual bool operator!=(double t_value) const; 

    virtual bool operator==(Expr_info expr) const = 0; 

    int testDummy(Expr_info expr) const;

    inline bool operator==(const Expr_c& expr) const;
    inline bool operator==(const Expr& expr) const;
    inline bool operator==(const Abstract& other) const;
    inline bool operator!=(Expr_info expr) const;
    inline bool operator!=(const Expr_c& expr) const;
    inline bool operator!=(const Expr& expr) const;
    inline bool operator!=(const Abstract& other) const;
    virtual Expr const &operator[](int iArg) const;

    virtual Expr& operator[](int iArg);


    // Comparison operators in terms of simplicity
    // For example x < x^2, (y*x+1) > (1+x*y) etc


    virtual bool operator<(Expr_info expr) const = 0;

    inline bool operator<(const Expr_c& expr) const {
        return *this < expr.get();
    }

    inline bool operator>(Expr_info expr) const {
        return *expr < this;
    }

    inline bool operator>(const Expr_c& expr) const {
        return *expr < this;
    }

    inline bool operator<=(Expr_info expr) const {
        return (not this->operator>(expr));
    }

    inline bool operator>=(Expr_info expr) const {
        return (not this->operator<(expr));
    }

    inline bool operator<=(const Expr_c& expr) const {
        return operator<=(expr.get());
    }

    inline bool operator>=(const Expr_c& expr) const {
        return operator>=(expr.get());
    }

};


/*************************************************/
// User-functions to create objects defined      //
// in this file                                  //
/*************************************************/

Expr sum_s(
        const Expr& leftOperand, 
        const Expr& rightOperand, 
        bool explicitSum = false);

Expr sum_s(const csl::vector_expr& operands, bool explicitSum = false);

Expr minus_(const Expr& leftOperand, const Expr& rightOperand);
Expr prod_s(const Expr& leftOperand, const Expr& rightOperand, bool explicitProd=0);

Expr prod_s(const csl::vector_expr& operands, bool explicitProd=false);

Expr fraction_s(const Expr& leftOperand, const Expr& rightOperand);

Expr pow_s(const Expr& leftOperand, const Expr& rightOperand);

Expr pow_s(const Expr& leftOperand, int value);

Expr sqrt_s(const Expr& operand);

Expr sqrt_s(int number);

Expr derivative_s(const Expr& leftOperand, const Expr& rightOperand, int order=1);
Expr derivative_s(const Expr& leftOperand, const Expr& rightOperand, int order, bool empty);

Expr derivative_s(const Expr& variable, int order=1);

Expr integral_s(const Expr& leftOperand, const Expr& rightOperand);
Expr integral_s(const Expr& leftOperand, const Expr& rightOperand, bool empty);
Expr integral_s(const Expr& leftOperand, const Expr& rightOperand, bool empty,
        const Expr& t_inf, const Expr& t_sup);
Expr integral_s(const Expr& variable);


Expr polynomial_s(const Expr& expr, const Expr& t_variable);

Expr polynomial_s(const csl::vector_expr& operands, const Expr& t_variable);


/*************************************************/
// Arithmetic operators                          //
/*************************************************/

Expr operator+(const Expr& a, const Expr& b);

Expr operator-(const Expr& a);

Expr operator-(const Expr& a, const Expr& b);

Expr operator*(const Expr& a, const Expr& b);

Expr operator/(const Expr& a, const Expr& b);

//Expr operator^(const Expr& a, const Expr& b);

class Expr: public std::shared_ptr<csl::Abstract> {

public:

    INHERIT_SHARED_PTR_CONSTRUCTOR(Expr, csl::Abstract)

    Expr (int value);
    Expr (long int value);
    Expr (long long int value);
    Expr (unsigned int value);
    Expr (unsigned long int value);
    Expr (unsigned long long int value);

    Expr (float value);
    Expr (double value);
    Expr (long double value);

    inline explicit
    operator Expr_info() const {
        return get();
    }

    inline csl::vector_expr::iterator begin() {
        return (**this).begin();
    }
    inline csl::vector_expr::iterator end() {
        return (**this).end();
    }
    inline csl::vector_expr::const_iterator begin() const {
        return (**this).begin();
    }
    inline csl::vector_expr::const_iterator end() const {
        return (**this).end();
    }

    template<class Index>
        inline Expr &operator[](Index &&index) {
            return (**this)[std::forward<Index>(index)];
        }

    template<class Index>
        inline Expr const &operator[](Index &&index) const {
            return (**this)[std::forward<Index>(index)];
        }

    Expr& operator+=(Expr const &other) {
        return (*this = *this + other);
    }

    Expr& operator-=(Expr const &other) {
        return (*this = *this - other);
    }

    Expr& operator*=(Expr const &other) {
        return (*this = *this * other);
    }

    Expr& operator/=(Expr const &other) {
        return (*this = *this / other);
    }
};

DEFINE_SHARED_PTR_OPERATOR(Expr)

std::ostream& operator<<(std::ostream& fout, const Expr& obj);


/*************************************************/
// Redefinition of operator for Expr alias       //
// std::shared_ptr<Abstract>. Allows then to use //
// operator with both syntaxes:                  //
// (*a op b) AND (a op b) with a and b Expr.     //
/*************************************************/

bool operator==(const Expr& a, const Expr& b);

bool operator!=(const Expr& a, const Expr& b);

bool operator>=(const Expr& a, const Expr& b);

bool operator<=(const Expr& a, const Expr& b);

bool operator>(const Expr& a, const Expr& b);

bool operator<(const Expr& a, const Expr& b);

bool operator|=(const Expr& a, const Expr& b);

bool operator&=(const Expr& a, const Expr& b);

    inline Expr Abstract::copy() const
    {
        return copy_unique();
    }

    inline bool Abstract::operator==(const Expr_c& expr) const {
        return *this == expr.get();
    }

    inline bool Abstract::operator==(const Expr& expr) const {
        return *this == expr.get();
    }

    inline bool Abstract::operator==(const Abstract& other) const {
        return *this == other.copy();
    }

    inline bool Abstract::operator!=(Expr_info expr) const {
        return not (*this == expr);
    }

    inline bool Abstract::operator!=(const Expr_c& expr) const {
        return *this != expr.get();
    }

    inline bool Abstract::operator!=(const Expr& expr) const {
        return *this != expr.get();
    }

    inline bool Abstract::operator!=(const Abstract& other) const {
        return *this != other.copy();
    }
} // End of namespace csl


#endif