Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $
You can buy this project and download/modify it how often you want.
z3-z3-4.13.0.src.math.lp.nex_creator.h Maven / Gradle / Ivy
/*++
Copyright (c) 2017 Microsoft Corporation
Author:
Lev Nachmanson (levnach)
Nikolaj Bjorner (nbjorner)
--*/
#pragma once
#include
#include
#include "util/map.h"
#include "math/lp/nex.h"
namespace nla {
struct occ {
unsigned m_occs; // number of occurences
unsigned m_power; // min power in occurences
occ() : m_occs(0), m_power(0) {}
occ(unsigned k, unsigned p) : m_occs(k), m_power(p) {}
// use the "name injection rule here"
friend std::ostream& operator<<(std::ostream& out, const occ& c) {
return out << "(occs:" << c.m_occs <<", pow:" << c.m_power << ")";
}
};
// the purpose of this class is to create nex objects, keep them,
// sort them, and delete them
class nex_creator {
ptr_vector m_allocated;
std::unordered_map m_occurences_map;
std::unordered_map m_powers;
unsigned_vector m_active_vars_weights;
public:
static std::string ch(unsigned j) {
std::stringstream s;
s << "j" << j;
return s.str();
}
// assuming that every lpvar is less than this number
void set_number_of_vars(unsigned k) {
m_active_vars_weights.resize(k);
}
unsigned get_number_of_vars() const {
return m_active_vars_weights.size();
}
void set_var_weight(unsigned j, unsigned weight) {
m_active_vars_weights[j] = weight;
}
private:
svector& active_vars_weights() { return m_active_vars_weights; }
const svector& active_vars_weights() const { return m_active_vars_weights; }
nex_mul* mk_mul(const vector& v) {
auto r = alloc(nex_mul, rational::zero(), v);
add_to_allocated(r);
return r;
}
void mul_args() { }
template
void mul_args(K e) {
m_mk_mul *= e;
}
template
void mul_args(K e, Args ... es) {
m_mk_mul *= e;
mul_args(es...);
}
template
void add_sum(T) { }
template
void add_sum(T& r, K e, Args ... es) {
r += e;
add_sum(r, es ...);
}
public:
nex* simplify(nex* e);
bool gt(lpvar j, lpvar k) const {
unsigned wj = m_active_vars_weights[j];
unsigned wk = m_active_vars_weights[k];
return wj != wk ? wj > wk : j > k;
}
void simplify_children_of_mul(vector& children, rational&);
nex* clone(const nex* a) {
switch (a->type()) {
case expr_type::VAR:
return mk_var(to_var(a)->var());
case expr_type::SCALAR:
return mk_scalar(to_scalar(a)->value());
case expr_type::MUL: {
mul_factory mf(*this);
for (const auto& p : a->to_mul()) {
mf *= nex_pow(clone(p.e()), p.pow());
}
mf *= a->to_mul().coeff();
return mf.mk();
}
case expr_type::SUM: {
sum_factory sf(*this);
for (nex const* e : a->to_sum()) {
sf += clone(e);
}
return sf.mk();
}
default:
UNREACHABLE();
break;
}
return nullptr;
}
const std::unordered_map& occurences_map() const { return m_occurences_map; }
std::unordered_map& occurences_map() { return m_occurences_map; }
const std::unordered_map& powers() const { return m_powers; }
std::unordered_map& powers() { return m_powers; }
void add_to_allocated(nex* r) {
m_allocated.push_back(r);
CTRACE("grobner_stats_d", m_allocated.size() % 1000 == 0, tout << "m_allocated.size() = " << m_allocated.size() << "\n";);
}
// NSB: we can use region allocation, but still need to invoke destructor
// because of 'rational' (and m_children in nex_mul unless we get rid of this)
void pop(unsigned sz) {
for (unsigned j = sz; j < m_allocated.size(); j++)
dealloc(m_allocated[j]);
m_allocated.resize(sz);
TRACE("grobner_stats_d", tout << "m_allocated.size() = " << m_allocated.size() << "\n";);
}
void clear() {
for (auto e : m_allocated)
dealloc(e);
m_allocated.clear();
}
nex_creator() : m_mk_mul(*this) {}
~nex_creator() {
clear();
}
unsigned size() const { return m_allocated.size(); }
class mul_factory {
nex_creator& c;
rational m_coeff;
vector m_args;
public:
mul_factory(nex_creator& c) :c(c), m_coeff(1) {}
void reset() { m_coeff = rational::one(); m_args.reset(); }
void operator*=(rational const& coeff) { m_coeff *= coeff; }
void operator*=(nex_pow const& p) { m_args.push_back(p); }
void operator*=(nex const* n) { m_args.push_back(nex_pow(n, 1)); }
bool empty() const { return m_args.empty(); }
nex_mul* mk() {
auto r = alloc(nex_mul, m_coeff, m_args);
c.add_to_allocated(r);
return r;
}
nex* mk_reduced() {
if (m_args.empty()) return c.mk_scalar(m_coeff);
if (m_coeff.is_one() && m_args.size() == 1 && m_args[0].pow() == 1) return m_args[0].e();
return mk();
}
};
class sum_factory {
nex_creator& c;
ptr_vector m_args;
public:
sum_factory(nex_creator& c) :c(c) {}
void reset() { m_args.reset(); }
void operator+=(nex const* n) { m_args.push_back(const_cast(n)); }
void operator+=(nex* n) { m_args.push_back(n); }
bool empty() const { return m_args.empty(); }
nex_sum* mk() { return c.mk_sum(m_args); }
};
mul_factory m_mk_mul;
nex_sum* mk_sum() {
ptr_vector v0;
return mk_sum(v0);
}
nex_sum* mk_sum(const ptr_vector& v) {
auto r = alloc(nex_sum, v);
add_to_allocated(r);
return r;
}
template
nex_sum* mk_sum(K e, Args... es) {
sum_factory sf(*this);
sf += e;
add_sum(sf, es...);
return sf.mk();
}
nex_var* mk_var(lpvar j) {
auto r = alloc(nex_var, j);
add_to_allocated(r);
return r;
}
nex_mul* mk_mul() {
auto r = alloc(nex_mul);
add_to_allocated(r);
return r;
}
template
nex_mul* mk_mul(K e, Args... es) {
m_mk_mul.reset();
m_mk_mul *= e;
mul_args(es...);
return m_mk_mul.mk();
}
nex_scalar* mk_scalar(const rational& v) {
auto r = alloc(nex_scalar, v);
add_to_allocated(r);
return r;
}
nex * mk_div(const nex& a, lpvar j);
nex * mk_div(const nex& a, const nex& b);
nex * mk_div_by_mul(const nex& a, const nex_mul& b);
nex * mk_div_sum_by_mul(const nex_sum& a, const nex_mul& b);
nex * mk_div_mul_by_mul(const nex_mul& a, const nex_mul& b);
nex * simplify_mul(nex_mul *e);
bool is_sorted(const nex_mul & e) const;
nex* simplify_sum(nex_sum *e);
bool is_simplified(const nex &e) const;
bool sum_is_simplified(const nex_sum& e) const;
bool mul_is_simplified(const nex_mul& e) const;
void mul_to_powers(vector& children);
void sort_join_sum(nex_sum & sum);
bool fill_join_map_for_sum(nex_sum & sum,
std::map& map,
std::unordered_set& existing_nex,
rational& common_scalar);
bool register_in_join_map(std::map&, nex const*, const rational&) const;
void simplify_children_of_sum(nex_sum & sum);
bool eat_scalar_pow(rational& r, const nex_pow& p, unsigned);
bool gt(const nex& a, const nex& b) const;
bool gt(const nex* a, const nex* b) const { return gt(*a, *b); }
template
bool gt_on_powers_mul_same_degree(const T&, const nex_mul& b) const;
bool gt_for_sort_join_sum(const nex* a, const nex* b) const;
bool gt_on_mul_mul(const nex_mul& a, const nex_mul& b) const;
bool gt_on_sum_sum(const nex_sum& a, const nex_sum& b) const;
bool gt_on_var_nex(const nex_var& a, const nex& b) const;
bool gt_on_mul_nex(nex_mul const&, const nex& b) const;
// just compare the underlying expressions
bool gt_on_nex_pow(const nex_pow& a, const nex_pow& b) const {
return gt(a.e(), b.e());
}
void process_map_pair(nex*e, const rational& coeff, nex_sum & sum, std::unordered_set&);
static bool equal(const nex*, const nex* );
nex* canonize(const nex*);
nex* canonize_mul(nex_mul*);
unsigned find_sum_in_mul(const nex_mul* a) const;
};
}
