Partial commit for Boolean, Predicate, and Order

diff --git a/src/boolean.c b/src/boolean.c
index 13070fa..ce6fad9 100644 (file)
--- 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 (file)
--- 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 (file)
--- 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 (file)
--- 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 (file)
--- 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 (file)
--- 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 (file)
--- 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; i<size; i++){
+        if(getVectorInt(order->set->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 (file)
--- 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 (file)
--- 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; i<numDomain; i++)
+        pushVectorSet(predicate->domains,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 (file)
--- 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