Compare.hh

Go to the documentation of this file.

#pragma once

#include "Storage.hh"
#include "Props.hh"
#include "properties/Indices.hh"

namespace cadabra {


int subtree_compare(const Properties*, 
                          Ex::iterator one, Ex::iterator two, 
                          int mod_prel=-2, bool checksets=true, int compare_multiplier=-2, 
                          bool literal_wildcards=false);


bool tree_less(const Properties*, 
                    const Ex& one, const Ex& two, 
                    int mod_prel=-2, bool checksets=true, int compare_multiplier=-2);
bool tree_equal(const Properties*, 
                     const Ex& one, const Ex& two, 
                     int mod_prel=-2, bool checksets=true, int compare_multiplier=-2);
bool tree_exact_less(const Properties*, 
                            const Ex& one, const Ex& two, 
                            int mod_prel=-2, bool checksets=true, int compare_multiplier=-2,
                            bool literal_wildcards=false);
bool tree_exact_equal(const Properties*, 
                             const Ex& one, const Ex& two,
                             int mod_prel=-2, bool checksets=true, int compare_multiplier=-2,
                             bool literal_wildcards=false);

bool subtree_less(const Properties*, 
                        Ex::iterator one, Ex::iterator two,
                        int mod_prel=-2, bool checksets=true, int compare_multiplier=-2);
bool subtree_equal(const Properties*, 
                         Ex::iterator one, Ex::iterator two,
                         int mod_prel=-2, bool checksets=true, int compare_multiplier=-2);
bool subtree_exact_less(const Properties*, 
                                Ex::iterator one, Ex::iterator two,
                                int mod_prel=-2, bool checksets=true, int compare_multiplier=-2,
                                bool literal_wildcards=false);
bool subtree_exact_equal(const Properties*, 
                                 Ex::iterator one, Ex::iterator two,
                                 int mod_prel=-2, bool checksets=true, int compare_multiplier=-2,
                                 bool literal_wildcards=false);

//
class tree_less_obj {
    public:
        tree_less_obj(const Properties*);
        bool operator()(const Ex& first, const Ex& second) const;
    private:
        const Properties* properties;
};

class tree_less_modprel_obj {
    public:
        tree_less_modprel_obj(const Properties*);
        bool operator()(const Ex& first, const Ex& second) const;
    private:
        const Properties* properties;
};

class tree_equal_obj {
    public:
        tree_equal_obj(const Properties*);
        bool operator()(const Ex& first, const Ex& second) const;
    private:
        const Properties* properties;
};

//
class tree_exact_less_obj {
    public:
        tree_exact_less_obj(const Properties*);
        bool operator()(const Ex& first, const Ex& second) const;
    private:
        const Properties* properties;
};

class tree_exact_less_mod_prel_obj {
    public:
        tree_exact_less_mod_prel_obj(const Properties*);
        bool operator()(const Ex& first, const Ex& second) const;
    private:
        const Properties* properties;
};

class tree_exact_equal_obj {
    public:
        tree_exact_equal_obj(const Properties*);
        bool operator()(const Ex& first, const Ex& second) const;
    private:
        const Properties* properties;
};

class tree_exact_equal_mod_prel_obj {
    public:
        tree_exact_equal_mod_prel_obj(const Properties*);
        bool operator()(const Ex& first, const Ex& second) const;
    private:
        const Properties* properties;
};


class tree_exact_less_for_indexmap_obj {
    public:
        bool operator()(const Ex& first, const Ex& second) const;
};

//
class tree_exact_less_no_wildcards_obj {
    public:
        tree_exact_less_no_wildcards_obj(); // disables property handling
        tree_exact_less_no_wildcards_obj(const Properties*);
        bool operator()(const Ex& first, const Ex& second) const;
    private:
        const Properties* properties;
};

class tree_exact_less_no_wildcards_mod_prel_obj {
    public:
        tree_exact_less_no_wildcards_mod_prel_obj(const Properties*);
        bool operator()(const Ex& first, const Ex& second) const;
    private:
        const Properties* properties;
};



class Ex_comparator {
    public:
        Ex_comparator(const Properties&);

        enum class match_t { 
         node_match=0,                 // a single node matches
            subtree_match=1,              // identical match, including index names
            match_index_less=2,           // structure match, indices in same set, but different names
            match_index_greater=3,
            no_match_indexpos_less=4,     // mismatch but only for index positions
           no_match_indexpos_greater=5,
            no_match_less=6,              // more serious mismatch
            no_match_greater=7 
        };

        enum class useprops_t {
            always=0,         // always use property info
            not_at_top,       // don't use property info at top level of the expression
            never=2           // never use property info
        };


        void    clear();


        match_t equal_subtree(Ex::iterator i1, Ex::iterator i2, 
                                     useprops_t use_props=useprops_t::always, bool ignore_parent_rel=false);


        match_t match_subproduct(const Ex&, 
                                         Ex::sibling_iterator lhs, Ex::sibling_iterator tofind, 
                                         Ex::sibling_iterator st, Ex::iterator conditions);


        match_t match_subsum(const Ex&, 
                                    Ex::sibling_iterator lhs, Ex::sibling_iterator tofind, 
                                    Ex::sibling_iterator st, Ex::iterator conditions);


        bool    satisfies_conditions(Ex::iterator conditions, std::string& error);


        typedef std::map<Ex, Ex, tree_exact_less_no_wildcards_obj>     replacement_map_t;
        replacement_map_t                                              replacement_map;


        typedef std::map<nset_t::iterator, Ex::iterator, nset_it_less> subtree_replacement_map_t;
        subtree_replacement_map_t                                      subtree_replacement_map;


        replacement_map_t                                              index_value_map;


        std::vector<Ex::sibling_iterator> factor_locations;
        std::vector<int>                  factor_moving_signs;
        multiplier_t                      term_ratio;

        bool lhs_contains_dummies;


        bool should_swap(Ex::iterator obj, match_t subtree_comparison) ;


        int  can_swap(Ex::iterator one, Ex::iterator two, match_t subtree_comparison,
                          bool ignore_implicit_indices=false);


        int  can_move_adjacent(Ex::iterator prod, Ex::sibling_iterator one, 
                                      Ex::sibling_iterator two, bool fix_one=false) ;

    protected:
        const Properties& properties;


        match_t compare(const Ex::iterator&, const Ex::iterator&, 
                             bool       nobrackets=false, 
                             useprops_t use_props=useprops_t::always,
                             bool       ignore_parent_rel=false);

      // Internal functions used by can_swap.
        int  can_swap_prod_obj(Ex::iterator prod, Ex::iterator obj, bool) ;
        int  can_swap_prod_prod(Ex::iterator prod1, Ex::iterator prod2, bool) ;
        int  can_swap_sum_obj(Ex::iterator sum, Ex::iterator obj, bool) ;
        int  can_swap_prod_sum(Ex::iterator prod, Ex::iterator sum, bool) ;
        int  can_swap_sum_sum(Ex::iterator sum1, Ex::iterator sum2, bool) ;
        int  can_swap_ilist_ilist(Ex::iterator obj1, Ex::iterator obj2);

        std::string tab() const;
        match_t     report(match_t r) const;

        static int offset;
};


class Ex_is_equivalent {
    public:
        Ex_is_equivalent(const Properties&);
        bool operator()(const Ex&, const Ex&);
    private:
        const Properties& properties;
};

class Ex_is_less {
    public:
        Ex_is_less(const Properties&, int mod_prel);
        bool operator()(const Ex&, const Ex&);
    private:
        const Properties& properties;
        int mod_prel;
};



}

bool operator<(const cadabra::Ex::iterator&, const cadabra::Ex::iterator&);
bool operator<(const cadabra::Ex&, const cadabra::Ex&);
std::ostream& operator<<(std::ostream&, cadabra::Ex_comparator::useprops_t up);