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();
 
 
            void    set_value_matches_index(bool);
 
 
            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_subtree(const Ex&, Ex::iterator i1, Ex::iterator i2, Ex::iterator conditions);
 
 
            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_swap_components(Ex::iterator one, Ex::iterator two,
                         match_t subtree_comparison);
 
 
            int  can_move_adjacent(Ex::iterator prod, Ex::sibling_iterator one,
                                   Ex::sibling_iterator two, bool fix_one=false) ;
 
 
            int  can_move_to_front(Ex&, Ex::iterator prod, Ex::sibling_iterator one);
            
 
            int  can_move_adjacent(Ex::iterator prod, const std::vector<Ex::sibling_iterator>& factors, Ex::sibling_iterator to_move);
 
        protected:
            const Properties& properties;
 
            bool value_matches_index;
 
 
            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);
            bool can_swap_different_indexsets(Ex::iterator obj1, Ex::iterator obj2);
 
            std::string tab() const;
            match_t     report(match_t r) const;
 
            bool name_match_with_autodeclare(Ex::sibling_iterator one, Ex::sibling_iterator two) 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);