BoolExpr::NNF*
BoolExpr::NNF::nnf(Region& r, Node* n, bool neg) {
switch (n->t) {
case NT_VAR: case NT_RLIN: case NT_MISC:
#ifdef GECODE_HAS_SET_VARS
case NT_RSET:
#endif
{
NNF* x = new (r) NNF;
x->t = n->t; x->u.a.neg = neg; x->u.a.x = n;
if (neg) {
x->p = 0; x->n = 1;
} else {
x->p = 1; x->n = 0;
}
return x;
}
case NT_NOT:
return nnf(r,n->l,!neg);
case NT_AND: case NT_OR:
{
NodeType t = ((n->t == NT_AND) == neg) ? NT_OR : NT_AND;
NNF* x = new (r) NNF;
x->t = t;
x->u.b.l = nnf(r,n->l,neg);
x->u.b.r = nnf(r,n->r,neg);
int p_l, n_l;
if ((x->u.b.l->t == t) || (x->u.b.l->t == NT_VAR)) {
p_l=x->u.b.l->p; n_l=x->u.b.l->n;
} else {
p_l=1; n_l=0;
}
int p_r, n_r;
if ((x->u.b.r->t == t) || (x->u.b.r->t == NT_VAR)) {
p_r=x->u.b.r->p; n_r=x->u.b.r->n;
} else {
p_r=1; n_r=0;
}
x->p = p_l+p_r;
x->n = n_l+n_r;
return x;
}
case NT_EQV:
{
NNF* x = new (r) NNF;
x->t = NT_EQV;
x->u.b.l = nnf(r,n->l,neg);
x->u.b.r = nnf(r,n->r,false);
x->p = 2; x->n = 0;
return x;
}
default:
GECODE_NEVER;
}
GECODE_NEVER;
return NULL;
}
int main(int argc,char ** argv){
formula *current,*old;
parserResult *result;
wwb* wwb,* oldWwb;
wwbList* list;
wwbListIterator it;
char *out;
int verifiable=0,carry=0;
char *example="((A0*A1*-A2)+(A0*A3*-A1*A2)+(A0*-A0*A3*A2)+(A0*-A3*A2)+(A0*A4*-A5))";//"(A0*(A0>(A1+A3))*((A0*A3)>A1)*(-A1+A2)*(-A1+-A2))";
if( argc == 1 ){
printf("Benutzung: %s <formel>\n",argv[0]);
result=string_to_formula_parser(example);
}else{
// testen des ersten Arguments
result=string_to_formula_parser(argv[1]);
}
if( result->error || *(result->rest) != 0 ){
// es ist keine Formel!
int pos=result->rest-argv[1];
printf("Nein, falsches Zeichen an Position %d: %s\n",pos,result->rest);
free(result);
return 1;
}
// es ist eine Formel
printf("Ja!\n");
old=result->formula;
current=remove_abbreviations(old);
free(old);
printf("Ohne Abkürzungen: ");
print_format(current);
printf("\n");
old=current;
current=nnf(old);
printf("NNF: ");
print_format(current);
printf("\n");
free_formula(current);
/* current=dnf(old);
printf("DNF: ");
print_format(current);
printf("\n");
free_formula(current);
current=knf(old);
printf("KNF: ");
print_format(current);
printf("\n");
free_formula(current);*/
wwb=wwb_from_formula(old);
list=is_verifiable_bf(old,wwb);
it=wwb_list_iterator_get(list);
out=(char *) malloc(sizeof(char)*100);
wwb_to_row_head_string(wwb,out);
printf("\n%s\n",out);
free(out);
while( wwb_list_iterator_valid(it) ){
out=(char *) malloc(sizeof(char)*100);
wwb_to_row_string(wwb_list_iterator_wbb(it),out);
printf("%s\n",out);
free(out);
it=wwb_list_iterator_next(it);
}
wwb=new_wwb();
verifiable=formula_is_verifiable_dpll(old,wwb);
if( verifiable ){
printf("Wahr für:\n");
print_wwb(wwb);
}else{
printf("Widerspruch\n");
}
oldWwb=wwb;
wwb=wwb_from_formula(old);
wwb_copy_to(oldWwb,wwb);
out=(char *) malloc(sizeof(char)*100);
wwb_to_row_head_string(wwb,out);
printf("\n%s\n",out);
free(out);
while( !carry ){
oldWwb=wwb;
if( formula_evaluate(old,wwb) ){
out=(char *) malloc(sizeof(char)*100);
wwb_to_row_string(wwb,out);
printf("%s\n",out);
free(out);
}
wwb=wwb_successor(oldWwb,&carry);
free_wwb(oldWwb);
}
free_wwb(wwb);
free(result);
return 0;
}
bool Qualify0(ScopeInfo& nf, const String& type, const String& usings, String& qt)
{ // Qualify single type based on scoping information
const Vector<String>& nd = nf.GetScopes(usings);
if(nd.GetCount()) {
LTIMING("First test");
qt = nd[0] + type;
if(nf.base.Find(qt) >= 0)
return true;
}
if(nf.GetScope() >= 0) {
int q = type.ReverseFind(':');
if(q > 0) {
LTIMING("Qualifying qualification");
ScopeInfo hnf(nf);
hnf.NoBases();
String qn;
String qs = type.Mid(0, q - 1);
if(IsDigit(*qs)) {
qt = type;
return true;
}
if(DoQualify(hnf, qs, usings, qn)) {
String tp = type.Mid(q + 1);
if(nf.base.Find(qn) >= 0) {
qt = qn + "::" + tp;
return true;
}
int scopei = nf.base.Find(qn);
if(scopei >= 0) {
ScopeInfo nnf(nf.base, scopei);
const Vector<String>& bs = nnf.GetBases();
for(int i = 0; i < bs.GetCount(); i++) {
qt = bs[i] + tp;
if(nf.base.Find(qt) >= 0)
return true;
}
}
}
if(nf.base.Find(qs) >= 0) {
qt = qs;
return true;
}
qt = type;
if(nf.base.Find(qt) >= 0) // e.g. std::string
return true;
qt = type.Mid(q + 1);
return true;
}
else {
LTIMING("Bases");
const Vector<String>& bs = nf.GetBases();
for(int i = 0; i < bs.GetCount(); i++) {
qt = bs[i] + type;
if(nf.base.Find(qt) >= 0)
return true;
}
}
}
if(type[0] != ':') {
LTIMING("Testing scopes");
for(int i = 1; i < nd.GetCount(); i++) {
qt = nd[i] + type;
if(nf.base.Find(qt) >= 0)
return true;
}
}
int q = type.Find(':');
if(q < 0)
return false;
return Qualify0(nf, type.Mid(q + 1), usings, qt);
}
void invariant_sett::strengthen(const exprt &expr)
{
exprt tmp(expr);
nnf(tmp);
strengthen_rec(tmp);
}
