src/Test/buildconstraintstest.c

   1 #include "csolver.h"
   2
   3 /**
   4  * e1={0, 1, 2}
   5  * e2={0, 1, 2}
   6  * e1 == e2
   7  * e3= e1+e2 {0, 1, 2, 3, 4}
   8  * e4 = f(e1, e2)
   9  *      0 1 => 0
  10  *      1 1 => 0
  11  *      2 1 => 2
  12  *      2 2 => 2
  13  * e3 == e4
  14  * Result: UNSAT!
  15  */
  16 int main(int numargs, char ** argv) {
  17         CSolver * solver=allocCSolver();
  18         uint64_t set1[]={0, 1, 2};
  19         uint64_t setbigarray[]={0, 1, 2, 3, 4};
  20
  21         Set * s=createSet(solver, 0, set1, 3);
  22         Set * setbig=createSet(solver, 0, setbigarray, 5);
  23         Element * e1=getElementVar(solver, s);
  24         Element * e2=getElementVar(solver, s);
  25         Set * domain[]={s, s};
  26         Predicate *equals=createPredicateOperator(solver, EQUALS, domain, 2);
  27         Element * inputs[]={e1, e2};
  28         Boolean * b=applyPredicate(solver, equals, inputs, 2, NULL);
  29         addConstraint(solver, b);
  30
  31         uint64_t set2[] = {2, 3};
  32         Set* rangef1 = createSet(solver, 1, set2, 2);
  33         Function * f1 = createFunctionOperator(solver, ADD, domain, 2, setbig, IGNORE);
  34
  35         Table* table = createTable(solver, domain, 2, s);
  36         uint64_t row1[] = {0, 1};
  37         uint64_t row2[] = {1, 1};
  38         uint64_t row3[] = {2, 1};
  39         uint64_t row4[] = {2, 2};
  40         addTableEntry(solver, table, row1, 2, 0);
  41         addTableEntry(solver, table, row2, 2, 0);
  42         addTableEntry(solver, table, row3, 2, 2);
  43         addTableEntry(solver, table, row4, 2, 2);
  44         Function * f2 = completeTable(solver, table, IGNOREBEHAVIOR); //its range would be as same as s
  45         Boolean* overflow = getBooleanVar(solver , 2);
  46         Element * e3 = applyFunction(solver, f1, inputs, 2, overflow);
  47         Element * e4 = applyFunction(solver, f2, inputs, 2, overflow);
  48         Set* domain2[] = {s,rangef1};
  49         Predicate* equal2 = createPredicateOperator(solver, EQUALS, domain2, 2);
  50         Element* inputs2 [] = {e4, e3};
  51         Boolean* pred = applyPredicate(solver, equal2, inputs2, 2, overflow);
  52         addConstraint(solver, pred);
  53
  54         if (startEncoding(solver)==1)
  55                 printf("e1=%llu e2=%llu\n", getElementValue(solver,e1), getElementValue(solver, e2));
  56         else
  57                 printf("UNSAT\n");
  58         deleteSolver(solver);
  59 }