SymEngine::FuncArgTracker Class Reference

Collaboration diagram for SymEngine::FuncArgTracker:

Public Member Functions
	FuncArgTracker (const std::vector< std::pair< RCP< const Basic >, vec_basic > > &funcs)
template<typename Container >
vec_basic	get_args_in_value_order (Container &argset)
unsigned	get_or_add_value_number (RCP< const Basic > value)
void	stop_arg_tracking (unsigned func_i)
std::map< unsigned, unsigned >	get_common_arg_candidates (std::set< unsigned > &argset, unsigned min_func_i)
template<typename Container1 , typename Container2 >
std::vector< unsigned >	get_subset_candidates (const Container1 &argset, const Container2 &restrict_to_funcset)
void	update_func_argset (unsigned func_i, const std::vector< unsigned > &new_args)

Data Fields
std::unordered_map< RCP< const Basic >, unsigned, RCPBasicHash, RCPBasicKeyEq >	value_numbers
vec_basic	value_number_to_value
std::vector< std::set< unsigned > >	arg_to_funcset
std::vector< std::set< unsigned > >	func_to_argset

Detailed Description

Definition at line 15 of file cse.cpp.

Constructor & Destructor Documentation

FuncArgTracker()

SymEngine::FuncArgTracker::FuncArgTracker ( const std::vector< std::pair< RCP< const Basic >, vec_basic > > &  funcs )

inline

Definition at line 26 of file cse.cpp.

    {
        arg_to_funcset.resize(funcs.size());
        for (unsigned func_i = 0; func_i < funcs.size(); func_i++) {
            std::set<unsigned> func_argset;
            for (auto &func_arg : funcs[func_i].second) {
                unsigned arg_number = get_or_add_value_number(func_arg);
                func_argset.insert(arg_number);
                arg_to_funcset[arg_number].insert(func_i);
            }
            func_to_argset.push_back(func_argset);
        }
    }

Member Function Documentation

get_args_in_value_order()

template<typename Container >

vec_basic SymEngine::FuncArgTracker::get_args_in_value_order ( Container &  argset )

inline

Definition at line 42 of file cse.cpp.

    {
        vec_basic v;
        for (unsigned i : argset) {
            v.push_back(value_number_to_value[i]);
        }
        return v;
    }

get_common_arg_candidates()

std::map< unsigned, unsigned > SymEngine::FuncArgTracker::get_common_arg_candidates ( std::set< unsigned > &  argset, unsigned  min_func_i  )

inline

Definition at line 78 of file cse.cpp.

    {
        std::map<unsigned, unsigned> count_map;
        std::vector<std::set<unsigned>> funcsets;
        for (unsigned arg : argset) {
            funcsets.push_back(arg_to_funcset[arg]);
        }
        // Sorted by size to make best use of the performance hack below.
        std::sort(funcsets.begin(), funcsets.end(),
                  [](const std::set<unsigned> &a, const std::set<unsigned> &b) {
                      return a.size() < b.size();
                  });
 
        for (unsigned i = 0; i < funcsets.size(); i++) {
            auto &funcset = funcsets[i];
            for (unsigned func_i : funcset) {
                if (func_i >= min_func_i) {
                    count_map[func_i] += 1;
                }
            }
        }
 
        /*auto &largest_funcset = funcsets[funcsets.size() - 1];
 
        // We pick the smaller of the two containers to iterate over to
        // reduce the number of items we have to look at.
 
        if (largest_funcset.size() < count_map.size()) {
            for (unsigned func_i : largest_funcset) {
                if (count_map[func_i] < 1) {
                    continue;
                }
                if (count_map.find(func_i) != count_map.end()) {
                    count_map[func_i] += 1;
                }
            }
        } else {
            for (auto &count_map_pair : count_map) {
                unsigned func_i = count_map_pair.first;
                if (count_map[func_i] < 1) {
                    continue;
                }
                if (largest_funcset.find(func_i) != largest_funcset.end()) {
                    count_map[func_i] += 1;
                }
            }
        }*/
        auto iter = count_map.begin();
        for (; iter != count_map.end();) {
            if (iter->second >= 2) {
                ++iter;
            } else {
                count_map.erase(iter++);
            }
        }
        return count_map;
    }

get_or_add_value_number()

unsigned SymEngine::FuncArgTracker::get_or_add_value_number ( RCP< const Basic >  value )

inline

Definition at line 51 of file cse.cpp.

    {
        unsigned nvalues = numeric_cast<unsigned>(value_numbers.size());
        auto ret = value_numbers.insert(std::make_pair(value, nvalues));
        bool inserted = ret.second;
        if (inserted) {
            value_number_to_value.push_back(value);
            arg_to_funcset.push_back(std::set<unsigned>());
            return nvalues;
        } else {
            return ret.first->second;
        }
    }

get_subset_candidates()

template<typename Container1 , typename Container2 >

std::vector< unsigned > SymEngine::FuncArgTracker::get_subset_candidates ( const Container1 &  argset, const Container2 &  restrict_to_funcset  )

inline

Definition at line 138 of file cse.cpp.

    {
        std::vector<unsigned> indices;
        for (auto f : restrict_to_funcset) {
            indices.push_back(f);
        }
        std::sort(std::begin(indices), std::end(indices));
        std::vector<unsigned> intersect_result;
        for (const auto &arg : argset) {
            std::set_intersection(indices.begin(), indices.end(),
                                  arg_to_funcset[arg].begin(),
                                  arg_to_funcset[arg].end(),
                                  std::back_inserter(intersect_result));
            intersect_result.swap(indices);
            intersect_result.clear();
        }
        return indices;
    }

stop_arg_tracking()

void SymEngine::FuncArgTracker::stop_arg_tracking ( unsigned  func_i )

inline

Definition at line 65 of file cse.cpp.

    {
        for (unsigned arg : func_to_argset[func_i]) {
            arg_to_funcset[arg].erase(func_i);
        }
    }

update_func_argset()

void SymEngine::FuncArgTracker::update_func_argset ( unsigned  func_i, const std::vector< unsigned > &  new_args  )

inline

Definition at line 158 of file cse.cpp.

    {
        // Update a function with a new set of arguments.
        auto &old_args = func_to_argset[func_i];
 
        std::set<unsigned> diff;
        std::set_difference(old_args.begin(), old_args.end(), new_args.begin(),
                            new_args.end(), std::inserter(diff, diff.begin()));
 
        for (auto &deleted_arg : diff) {
            arg_to_funcset[deleted_arg].erase(func_i);
        }
 
        diff.clear();
        std::set_difference(new_args.begin(), new_args.end(), old_args.begin(),
                            old_args.end(), std::inserter(diff, diff.begin()));
 
        for (auto &added_arg : diff) {
            arg_to_funcset[added_arg].insert(func_i);
        }
 
        func_to_argset[func_i].clear();
        func_to_argset[func_i].insert(new_args.begin(), new_args.end());
    }

Field Documentation

arg_to_funcset

std::vector<std::set<unsigned> > SymEngine::FuncArgTracker::arg_to_funcset

Definition at line 22 of file cse.cpp.

func_to_argset

std::vector<std::set<unsigned> > SymEngine::FuncArgTracker::func_to_argset

Definition at line 23 of file cse.cpp.

value_number_to_value

vec_basic SymEngine::FuncArgTracker::value_number_to_value

Definition at line 21 of file cse.cpp.

value_numbers

std::unordered_map<RCP<const Basic>, unsigned, RCPBasicHash, RCPBasicKeyEq> SymEngine::FuncArgTracker::value_numbers

Definition at line 20 of file cse.cpp.

---

The documentation for this class was generated from the following file:

• /home/runner/work/symengine/symengine/symengine/cse.cpp