mirror of
https://github.com/Z3Prover/z3
synced 2025-04-07 18:05:21 +00:00
322 lines
8.9 KiB
C++
Executable file
322 lines
8.9 KiB
C++
Executable file
/*++
|
|
Copyright (c) 2011 Microsoft Corporation
|
|
|
|
Module Name:
|
|
|
|
iz3scopes.cpp
|
|
|
|
Abstract:
|
|
|
|
Calculations with scopes, for both sequence and tree interpolation.
|
|
|
|
Author:
|
|
|
|
Ken McMillan (kenmcmil)
|
|
|
|
Revision History:
|
|
|
|
--*/
|
|
|
|
#include <assert.h>
|
|
|
|
#include <algorithm>
|
|
|
|
#include "iz3scopes.h"
|
|
|
|
|
|
/** computes the least common ancestor of two nodes in the tree, or SHRT_MAX if none */
|
|
int scopes::tree_lca(int n1, int n2){
|
|
if(!tree_mode())
|
|
return std::max(n1,n2);
|
|
if(n1 == SHRT_MIN) return n2;
|
|
if(n2 == SHRT_MIN) return n1;
|
|
if(n1 == SHRT_MAX || n2 == SHRT_MAX) return SHRT_MAX;
|
|
while(n1 != n2){
|
|
if(n1 == SHRT_MAX || n2 == SHRT_MAX) return SHRT_MAX;
|
|
assert(n1 >= 0 && n2 >= 0 && n1 < (int)parents.size() && n2 < (int)parents.size());
|
|
if(n1 < n2) n1 = parents[n1];
|
|
else n2 = parents[n2];
|
|
}
|
|
return n1;
|
|
}
|
|
|
|
/** computes the greatest common descendant two nodes in the tree, or SHRT_MIN if none */
|
|
int scopes::tree_gcd(int n1, int n2){
|
|
if(!tree_mode())
|
|
return std::min(n1,n2);
|
|
int foo = tree_lca(n1,n2);
|
|
if(foo == n1) return n2;
|
|
if(foo == n2) return n1;
|
|
return SHRT_MIN;
|
|
}
|
|
|
|
#ifndef FULL_TREE
|
|
|
|
/** test whether a tree node is contained in a range */
|
|
bool scopes::in_range(int n, const range &rng){
|
|
return tree_lca(rng.lo,n) == n && tree_gcd(rng.hi,n) == n;
|
|
}
|
|
|
|
/** test whether two ranges of tree nodes intersect */
|
|
bool scopes::ranges_intersect(const range &rng1, const range &rng2){
|
|
return tree_lca(rng1.lo,rng2.hi) == rng2.hi && tree_lca(rng1.hi,rng2.lo) == rng1.hi;
|
|
}
|
|
|
|
|
|
bool scopes::range_contained(const range &rng1, const range &rng2){
|
|
return tree_lca(rng2.lo,rng1.lo) == rng1.lo
|
|
&& tree_lca(rng1.hi,rng2.hi) == rng2.hi;
|
|
}
|
|
|
|
scopes::range scopes::range_lub(const range &rng1, const range &rng2){
|
|
range res;
|
|
res.lo = tree_gcd(rng1.lo,rng2.lo);
|
|
res.hi = tree_lca(rng1.hi,rng2.hi);
|
|
return res;
|
|
}
|
|
|
|
scopes::range scopes::range_glb(const range &rng1, const range &rng2){
|
|
range res;
|
|
res.lo = tree_lca(rng1.lo,rng2.lo);
|
|
res.hi = tree_gcd(rng1.hi,rng2.hi);
|
|
return res;
|
|
}
|
|
|
|
#else
|
|
|
|
|
|
namespace std {
|
|
template <>
|
|
class hash<scopes::range_lo > {
|
|
public:
|
|
size_t operator()(const scopes::range_lo &p) const {
|
|
return p.lo + (size_t)p.next;
|
|
}
|
|
};
|
|
}
|
|
|
|
template <> inline
|
|
size_t stdext::hash_value<scopes::range_lo >(const scopes::range_lo& p)
|
|
{
|
|
std::hash<scopes::range_lo> h;
|
|
return h(p);
|
|
}
|
|
|
|
namespace std {
|
|
template <>
|
|
class less<scopes::range_lo > {
|
|
public:
|
|
bool operator()(const scopes::range_lo &x, const scopes::range_lo &y) const {
|
|
return x.lo < y.lo || x.lo == y.lo && (size_t)x.next < (size_t)y.next;
|
|
}
|
|
};
|
|
}
|
|
|
|
|
|
struct range_op {
|
|
scopes::range_lo *x, *y;
|
|
int hi;
|
|
range_op(scopes::range_lo *_x, scopes::range_lo *_y, int _hi){
|
|
x = _x; y = _y; hi = _hi;
|
|
}
|
|
};
|
|
|
|
namespace std {
|
|
template <>
|
|
class hash<range_op > {
|
|
public:
|
|
size_t operator()(const range_op &p) const {
|
|
return (size_t) p.x + (size_t)p.y + p.hi;
|
|
}
|
|
};
|
|
}
|
|
|
|
template <> inline
|
|
size_t stdext::hash_value<range_op >(const range_op& p)
|
|
{
|
|
std::hash<range_op> h;
|
|
return h(p);
|
|
}
|
|
|
|
namespace std {
|
|
template <>
|
|
class less<range_op > {
|
|
public:
|
|
bool operator()(const range_op &x, const range_op &y) const {
|
|
return (size_t)x.x < (size_t)y.x || x.x == y.x &&
|
|
((size_t)x.y < (size_t)y.y || x.y == y.y && x.hi < y.hi);
|
|
}
|
|
};
|
|
}
|
|
|
|
struct range_tables {
|
|
hash_map<scopes::range_lo, scopes::range_lo *> unique;
|
|
hash_map<range_op,scopes::range_lo *> lub;
|
|
hash_map<range_op,scopes::range_lo *> glb;
|
|
};
|
|
|
|
|
|
scopes::range_lo *scopes::find_range_lo(int lo, range_lo *next){
|
|
range_lo foo(lo,next);
|
|
std::pair<range_lo,range_lo *> baz(foo,(range_lo *)0);
|
|
std::pair<hash_map<range_lo,scopes::range_lo *>::iterator,bool> bar = rt->unique.insert(baz);
|
|
if(bar.second)
|
|
bar.first->second = new range_lo(lo,next);
|
|
return bar.first->second;
|
|
//std::pair<hash_set<scopes::range_lo>::iterator,bool> bar = rt->unique.insert(foo);
|
|
// const range_lo *baz = &*(bar.first);
|
|
// return (range_lo *)baz; // exit const hell
|
|
}
|
|
|
|
scopes::range_lo *scopes::range_lub_lo(range_lo *rng1, range_lo *rng2){
|
|
if(!rng1) return rng2;
|
|
if(!rng2) return rng1;
|
|
if(rng1->lo > rng2->lo)
|
|
std::swap(rng1,rng2);
|
|
std::pair<range_op,range_lo *> foo(range_op(rng1,rng2,0),(range_lo *)0);
|
|
std::pair<hash_map<range_op,scopes::range_lo *>::iterator,bool> bar = rt->lub.insert(foo);
|
|
range_lo *&res = bar.first->second;
|
|
if(!bar.second) return res;
|
|
if(!(rng1->next && rng1->next->lo <= rng2->lo)){
|
|
for(int lo = rng1->lo; lo <= rng2->lo; lo = parents[lo])
|
|
if(lo == rng2->lo)
|
|
{rng2 = rng2->next; break;}
|
|
}
|
|
range_lo *baz = range_lub_lo(rng1->next,rng2);
|
|
res = find_range_lo(rng1->lo,baz);
|
|
return res;
|
|
}
|
|
|
|
|
|
scopes::range_lo *scopes::range_glb_lo(range_lo *rng1, range_lo *rng2, int hi){
|
|
if(!rng1) return rng1;
|
|
if(!rng2) return rng2;
|
|
if(rng1->lo > rng2->lo)
|
|
std::swap(rng1,rng2);
|
|
std::pair<range_op,range_lo *> cand(range_op(rng1,rng2,hi),(range_lo *)0);
|
|
std::pair<hash_map<range_op,scopes::range_lo *>::iterator,bool> bar = rt->glb.insert(cand);
|
|
range_lo *&res = bar.first->second;
|
|
if(!bar.second) return res;
|
|
range_lo *foo;
|
|
if(!(rng1->next && rng1->next->lo <= rng2->lo)){
|
|
int lim = hi;
|
|
if(rng1->next) lim = std::min(lim,rng1->next->lo);
|
|
int a = rng1->lo, b = rng2->lo;
|
|
while(a != b && b <= lim){
|
|
a = parents[a];
|
|
if(a > b)std::swap(a,b);
|
|
}
|
|
if(a == b && b <= lim){
|
|
foo = range_glb_lo(rng1->next,rng2->next,hi);
|
|
foo = find_range_lo(b,foo);
|
|
}
|
|
else
|
|
foo = range_glb_lo(rng2,rng1->next,hi);
|
|
}
|
|
else foo = range_glb_lo(rng1->next,rng2,hi);
|
|
res = foo;
|
|
return res;
|
|
}
|
|
|
|
/** computes the lub (smallest containing subtree) of two ranges */
|
|
scopes::range scopes::range_lub(const range &rng1, const range &rng2){
|
|
int hi = tree_lca(rng1.hi,rng2.hi);
|
|
if(hi == SHRT_MAX) return range_full();
|
|
range_lo *lo = range_lub_lo(rng1.lo,rng2.lo);
|
|
return range(hi,lo);
|
|
}
|
|
|
|
/** computes the glb (intersection) of two ranges */
|
|
scopes::range scopes::range_glb(const range &rng1, const range &rng2){
|
|
if(rng1.hi == SHRT_MAX) return rng2;
|
|
if(rng2.hi == SHRT_MAX) return rng1;
|
|
int hi = tree_gcd(rng1.hi,rng2.hi);
|
|
range_lo *lo = hi == SHRT_MIN ? 0 : range_glb_lo(rng1.lo,rng2.lo,hi);
|
|
if(!lo) hi = SHRT_MIN;
|
|
return range(hi,lo);
|
|
}
|
|
|
|
/** is this range empty? */
|
|
bool scopes::range_is_empty(const range &rng){
|
|
return rng.hi == SHRT_MIN;
|
|
}
|
|
|
|
/** return an empty range */
|
|
scopes::range scopes::range_empty(){
|
|
return range(SHRT_MIN,0);
|
|
}
|
|
|
|
/** return a full range */
|
|
scopes::range scopes::range_full(){
|
|
return range(SHRT_MAX,0);
|
|
}
|
|
|
|
/** return the maximal element of a range */
|
|
int scopes::range_max(const range &rng){
|
|
return rng.hi;
|
|
}
|
|
|
|
/** return a minimal (not necessarily unique) element of a range */
|
|
int scopes::range_min(const range &rng){
|
|
if(rng.hi == SHRT_MAX) return SHRT_MIN;
|
|
return rng.lo ? rng.lo->lo : SHRT_MAX;
|
|
}
|
|
|
|
|
|
/** return range consisting of downward closure of a point */
|
|
scopes::range scopes::range_downward(int _hi){
|
|
std::vector<bool> descendants(parents.size());
|
|
for(int i = descendants.size() - 1; i >= 0 ; i--)
|
|
descendants[i] = i == _hi || parents[i] < parents.size() && descendants[parents[i]];
|
|
for(unsigned i = 0; i < descendants.size() - 1; i++)
|
|
if(parents[i] < parents.size())
|
|
descendants[parents[i]] = false;
|
|
range_lo *foo = 0;
|
|
for(int i = descendants.size() - 1; i >= 0; --i)
|
|
if(descendants[i]) foo = find_range_lo(i,foo);
|
|
return range(_hi,foo);
|
|
}
|
|
|
|
/** add an element to a range */
|
|
void scopes::range_add(int i, range &n){
|
|
range foo = range(i, find_range_lo(i,0));
|
|
n = range_lub(foo,n);
|
|
}
|
|
|
|
/** Choose an element of rng1 that is near to rng2 */
|
|
int scopes::range_near(const range &rng1, const range &rng2){
|
|
|
|
int frame;
|
|
int thing = tree_lca(rng1.hi,rng2.hi);
|
|
if(thing != rng1.hi) return rng1.hi;
|
|
range line = range(rng1.hi,find_range_lo(rng2.hi,(range_lo *)0));
|
|
line = range_glb(line,rng1);
|
|
return range_min(line);
|
|
}
|
|
|
|
|
|
/** test whether a tree node is contained in a range */
|
|
bool scopes::in_range(int n, const range &rng){
|
|
range r = range_empty();
|
|
range_add(n,r);
|
|
r = range_glb(rng,r);
|
|
return !range_is_empty(r);
|
|
}
|
|
|
|
/** test whether two ranges of tree nodes intersect */
|
|
bool scopes::ranges_intersect(const range &rng1, const range &rng2){
|
|
range r = range_glb(rng1,rng2);
|
|
return !range_is_empty(r);
|
|
}
|
|
|
|
|
|
bool scopes::range_contained(const range &rng1, const range &rng2){
|
|
range r = range_glb(rng1,rng2);
|
|
return r.hi == rng1.hi && r.lo == rng1.lo;
|
|
}
|
|
|
|
|
|
#endif
|
|
|
|
|