From af3c00c52ce4b2a13368628423312ade8aeecfbb Mon Sep 17 00:00:00 2001 From: Hamed Date: Fri, 16 Jun 2017 10:01:08 -0700 Subject: [PATCH] Partial commit for Boolean, Predicate, and Order --- src/boolean.c | 15 +++++++++++++++ src/boolean.h | 10 +++++++++- src/csolver.c | 29 ++++++++++++++++++----------- src/csolver.h | 13 +++++++------ src/function.h | 2 ++ src/ops.h | 2 ++ src/order.c | 28 ++++++++++++++++++++++++++++ src/order.h | 9 ++++++++- src/predicate.c | 11 +++++++++++ src/predicate.h | 8 +++++++- 10 files changed, 107 insertions(+), 20 deletions(-) diff --git a/src/boolean.c b/src/boolean.c index 13070fa..ce6fad9 100644 --- a/src/boolean.c +++ b/src/boolean.c @@ -1 +1,16 @@ #include "boolean.h" + +Boolean* allocBoolean(VarType t){ + Boolean* tmp = (Boolean*) ourmalloc(sizeof (Boolean)); + tmp->vtype=t; + tmp->btype=_BOOLEAN; + return tmp; +} + +Boolean* allocBooleanOrder(Order* order,uint64_t first, uint64_t second){ + Boolean* tmp = (Boolean*) ourmalloc(sizeof (Boolean)); + tmp ->btype= _ORDER; + tmp->order = order; + tmp->first=first; + tmp->second=second; +} \ No newline at end of file diff --git a/src/boolean.h b/src/boolean.h index 5e8c5a5..fcd4751 100644 --- a/src/boolean.h +++ b/src/boolean.h @@ -2,7 +2,15 @@ #define BOOLEAN_H #include "classlist.h" #include "mymemory.h" - +#include "ops.h" struct Boolean { + VarType vtype; + enum BooleanType btype; + Order* order; + uint64_t first; + uint64_t second; }; + +Boolean* allocBoolean(VarType t); +Boolean* allocBooleanOrder(Order* order,uint64_t first, uint64_t second); #endif diff --git a/src/csolver.c b/src/csolver.c index d1b0f58..5ddaaed 100644 --- a/src/csolver.c +++ b/src/csolver.c @@ -2,6 +2,8 @@ #include "set.h" #include "mutableset.h" #include "element.h" +#include "boolean.h" +#include "predicate.h" CSolver * allocCSolver() { CSolver * tmp=(CSolver *) ourmalloc(sizeof(CSolver)); @@ -66,26 +68,29 @@ Element * getElementVar(CSolver *this, Set * set) { } Boolean * getBooleanVar(CSolver *solver, VarType type) { - return NULL; + Boolean* boolean= allocBoolean(type); + pushVectorBoolean(solver->constraints, boolean); + return boolean; } -Function * createFunctionOperator(CSolver *solver, enum ArithOp op, Set ** domain, Set * range, enum OverFlowBehavior overflowbehavior, Boolean * overflowstatus) { +Function * createFunctionOperator(CSolver *solver, enum ArithOp op, Set ** domain, uint numDomain, Set * range, + enum OverFlowBehavior overflowbehavior, Boolean * overflowstatus) { return NULL; } -Function * createFunctionOperatorPure(CSolver *solver, enum ArithOp op) { - return NULL; -} +//Function * createFunctionOperatorPure(CSolver *solver, enum ArithOp op) { +// return NULL; +//} -Predicate * createPredicateOperator(CSolver *solver, enum CompOp op, Set ** domain) { - return NULL; +Predicate * createPredicateOperator(CSolver *solver, enum CompOp op, Set ** domain, uint numDomain) { + return allocPredicate(op, domain,numDomain); } -Table * createTable(CSolver *solver, Set **domains, Set * range) { +Table * createTable(CSolver *solver, Set **domains, uint numDomain, Set * range) { return NULL; } -void addTableEntry(CSolver *solver, Element ** inputs, Element *result) { +void addTableEntry(CSolver *solver, uint64_t* inputs, uint inputSize, uint64_t result) { } Function * completeTable(CSolver *solver, Table * table) { @@ -109,9 +114,11 @@ void addBoolean(CSolver *this, Boolean * constraint) { } Order * createOrder(CSolver *solver, enum OrderType type, Set * set) { - return NULL; + return allocOrder(type, set); } Boolean * orderConstraint(CSolver *solver, Order * order, uint64_t first, uint64_t second) { - return NULL; + Boolean* constraint = allocBooleanOrder(order, first, second); + pushVectorBoolean(solver->constraints,constraint); + return constraint; } diff --git a/src/csolver.h b/src/csolver.h index 63ba766..3972f6c 100644 --- a/src/csolver.h +++ b/src/csolver.h @@ -21,14 +21,15 @@ uint64_t createUniqueItem(CSolver *, MutableSet * set); Element * getElementVar(CSolver *, Set * set); Boolean * getBooleanVar(CSolver *, VarType type); -Function * createFunctionOperator(CSolver *, enum ArithOp op, Set ** domain, Set * range, enum OverFlowBehavior overflowbehavior, Boolean * overflowstatus); +Function * createFunctionOperator(CSolver *solver, enum ArithOp op, Set ** domain, uint numDomain, Set * range, + enum OverFlowBehavior overflowbehavior, Boolean * overflowstatus); //Does Not Overflow -Function * createFunctionOperatorPure(CSolver *, enum ArithOp op); -Predicate * createPredicateOperator(CSolver *, enum CompOp op, Set ** domain); +//Function * createFunctionOperatorPure(CSolver *, enum ArithOp op); +Predicate * createPredicateOperator(CSolver *solver, enum CompOp op, Set ** domain, uint numDomain); -Table * createTable(CSolver *, Set **domains, Set * range); -void addTableEntry(CSolver *, Element ** inputs, Element *result); -Function * completeTable(CSolver *, struct Table *); +Table * createTable(CSolver *solver, Set **domains, uint numDomain, Set * range); +void addTableEntry(CSolver *solver, uint64_t* inputs, uint inputSize, uint64_t result); +Function * completeTable(CSolver *, Table *); Element * applyFunction(CSolver *, Function * function, Element ** array); Boolean * applyPredicate(CSolver *, Predicate * predicate, Element ** inputs); diff --git a/src/function.h b/src/function.h index da5087b..f023f4a 100644 --- a/src/function.h +++ b/src/function.h @@ -4,5 +4,7 @@ #include "mymemory.h" struct Function { + + Table* table; }; #endif diff --git a/src/ops.h b/src/ops.h index 40e6f99..3990aec 100644 --- a/src/ops.h +++ b/src/ops.h @@ -14,4 +14,6 @@ enum OrderType {PARTIAL, TOTAL}; */ enum OverFlowBehavior {IGNORE, WRAPAROUND, FLAGFORCESOVERFLOW, OVERFLOWSETSFLAG, FLAGIFFOVERFLOW}; +enum BooleanType {_ORDER, _BOOLEAN}; + #endif diff --git a/src/order.c b/src/order.c index 727b2dd..2f8381e 100644 --- a/src/order.c +++ b/src/order.c @@ -1 +1,29 @@ #include "order.h" +#include "structs.h" +#include "set.h" + + +Order* allocOrder(enum OrderType type, Set * set){ + Order* order = (Order*)ourmalloc(sizeof(Order)); + order->set=set; + order->constraints = allocDefVectorBoolean(); + order->type=type; + return order; +} + +Boolean* getOrderConstraint(Order* order, uint64_t first, uint64_t second){ + uint size = getSizeVectorInt(order->set->members); + //First we need to make sure that first and second are part of the list! + bool exist1=false, exist2=false; + for(int i=0; iset->members, i)==first){ + exist1=true; + }else if(getVectorInt(order->set->members, i) == second){ + exist2=true; + }else if(exist1 && exist2){ + break; + } + } + ASSERT(exist1 && exist2); + +} \ No newline at end of file diff --git a/src/order.h b/src/order.h index b164a11..08bc2a7 100644 --- a/src/order.h +++ b/src/order.h @@ -2,7 +2,14 @@ #define ORDER_H #include "classlist.h" #include "mymemory.h" - +#include "structs.h" +#include "ops.h" struct Order { + enum OrderType type; + Set * set; + VectorBoolean* constraints; }; + +Order* allocOrder(enum OrderType type, Set * set); +Boolean* getOrderConstraint(Order* order,uint64_t first, uint64_t second); #endif diff --git a/src/predicate.c b/src/predicate.c index dcec97a..2beef61 100644 --- a/src/predicate.c +++ b/src/predicate.c @@ -1 +1,12 @@ #include "predicate.h" +#include "structs.h" + + +Predicate* allocPredicate(enum CompOp op, Set ** domain, uint numDomain){ + Predicate* predicate = (Predicate*) ourmalloc(sizeof(Predicate)); + predicate->domains = allocDefVectorSet(); + for(uint i=0; idomains,domain[i]); + predicate->op=op; + return predicate; +} \ No newline at end of file diff --git a/src/predicate.h b/src/predicate.h index 9a17669..06c54bb 100644 --- a/src/predicate.h +++ b/src/predicate.h @@ -2,8 +2,14 @@ #define PREDICATE_H #include "classlist.h" #include "mymemory.h" +#include "ops.h" +#include "structs.h" struct Predicate { - + enum CompOp op; + VectorSet* domains; }; + + +Predicate* allocPredicate(enum CompOp op, Set ** domain, uint numDomain); #endif -- 2.34.1