mirrors/z3
3
0
Fork 0
mirror of https://github.com/Z3Prover/z3 synced 2025-04-10 19:27:06 +00:00
Code Activity

operator+

Browse source 
Signed-off-by: Nikolaj Bjorner <nbjorner@microsoft.com>
This commit is contained in:
Nikolaj Bjorner 2019-04-13 16:30:47 -07:00
parent 1123b47fb7
commit f0c013843f
3 changed files with 5 additions and 10 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

5
src/ast/ast_util.cpp
View file

@ -373,7 +373,4 @@ static app_ref plus(ast_manager& m, expr* a, int i) {
return app_ref(arith.mk_add(a, arith.mk_int(i)), m);
}
app_ref operator+(expr_ref& a, expr* b) { return plus(a.m(), a, b); }
app_ref operator+(app_ref& a, expr* b) { return plus(a.m(), a, b); }
app_ref operator+(expr_ref& a, int i) { return plus(a.m(), a, i); }
app_ref operator+(app_ref& a, int i) { return plus(a.m(), a, i); }
app_ref operator+(expr_ref& a, expr_ref& b) { return plus(a.m(), a, b); }

5
src/ast/ast_util.h
View file

@ -120,10 +120,7 @@ inline app_ref operator|(expr_ref& a, expr* b) { return app_ref(a.m().mk_or(a, b
inline app_ref operator|(app_ref& a, expr* b) { return app_ref(a.m().mk_or(a, b), a.m()); }
inline app_ref operator|(var_ref& a, expr* b) { return app_ref(a.m().mk_or(a, b), a.m()); }
inline app_ref operator|(quantifier_ref& a, expr* b) { return app_ref(a.m().mk_or(a, b), a.m()); }
app_ref operator+(expr_ref& a, expr* b);
app_ref operator+(app_ref& a, expr* b);
app_ref operator+(expr_ref& a, int i);
app_ref operator+(app_ref& a, int i);
app_ref operator+(expr_ref& a, expr_ref& b);
/**
Return (or args[0] ... args[num_args-1]) if num_args >= 2

5
src/smt/theory_array_bapa.cpp
View file

@ -35,8 +35,7 @@ Q: Is this sufficient? Axiom A1 could be adjusted to add new elements i' until t
This is quite bad when k is very large. Instead rely on stably infiniteness or other domain properties of the theories.
When A is finite domain, or there are quantifiers there could be constraints that force domain sizes so domain sizes may have
to be enforced. A succinct way would be through domain comprehension assertions. Thus, if we have
S[i1],.., S[ik], !S[j1],...,!S[jl] asserted on integer domain i, then
to be enforced. A succinct way would be through domain comprehension assertions.
Finite domains:
@ -53,6 +52,8 @@ Finite domains:
---------------------------------------------------------------
Size(S, n) n fresh.
Model construction for infinite domains when all Size(S, m) are negative for S.
*/
#include "ast/ast_util.h"