Partial commit for Boolean, Predicate, and Order

diff --git a/src/boolean.c b/src/boolean.c
index 13070fa502d786a6aa13003bf271450e513377e6..ce6fad950d39d66d85dac78a28358ec72e0318b6 100644 (file)
--- a/src/boolean.c
+++ b/src/boolean.c
@@ -1 +1,16 @@
 #include "boolean.h"
 #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 5e8c5a5e6f9a225af80543f9d1fc4b2f1411cd14..fcd4751dad5cbaa57b8f1d5df8d8788a32b9f735 100644 (file)
--- a/src/boolean.h
+++ b/src/boolean.h
@@ -2,7 +2,15 @@
 #define BOOLEAN_H
 #include "classlist.h"
 #include "mymemory.h"
 #define BOOLEAN_H
 #include "classlist.h"
 #include "mymemory.h"

-
+#include "ops.h"

 struct  Boolean {
 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
 #endif

diff --git a/src/csolver.c b/src/csolver.c
index d1b0f5830420ba46a4c2cb3ef87f18262d4bcb3a..5ddaaeda13e13e79db6bb291f2705418217241c4 100644 (file)
--- a/src/csolver.c
+++ b/src/csolver.c
@@ -2,6 +2,8 @@
 #include "set.h"
 #include "mutableset.h"
 #include "element.h"
 #include "set.h"
 #include "mutableset.h"
 #include "element.h"

+#include "boolean.h"
+#include "predicate.h"

 
 CSolver * allocCSolver() {
        CSolver * tmp=(CSolver *) ourmalloc(sizeof(CSolver));
 
 CSolver * allocCSolver() {
        CSolver * tmp=(CSolver *) ourmalloc(sizeof(CSolver));


@@ -66,26 +68,29 @@ Element * getElementVar(CSolver *this, Set * set) {
 }
 
 Boolean * getBooleanVar(CSolver *solver, VarType type) {
 }
 
 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;
 }
 
        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;
 }
 
        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) {
 }
 
 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) {
 }
 
 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) {
 }
 
 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 63ba766206e5d125fbc074babcf84eb22271e866..3972f6c7c0f08ffa7cc85b8c157ea7b5fe9c90f9 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);
 
 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
 //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);
 
 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 da5087b579e06373e3e25c193f2f37d79c5f77d2..f023f4aad8dda58bdcae205a83432bcd7e54d309 100644 (file)
--- a/src/function.h
+++ b/src/function.h
@@ -4,5 +4,7 @@
 #include "mymemory.h"
 
 struct Function {
 #include "mymemory.h"
 
 struct Function {

+    
+    Table* table;

 };
 #endif
 };
 #endif

diff --git a/src/ops.h b/src/ops.h
index 40e6f9933a05180f45614b433a6b3094dc406169..3990aec8080b666088ed96ba1d151a0e5a7692b4 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 OverFlowBehavior {IGNORE, WRAPAROUND, FLAGFORCESOVERFLOW, OVERFLOWSETSFLAG, FLAGIFFOVERFLOW};
 

+enum BooleanType {_ORDER, _BOOLEAN};
+

 #endif
 #endif

diff --git a/src/order.c b/src/order.c
index 727b2dd3888d35a3bf45fd292a4a9142f2d7feba..2f8381e234e59d0c698fbba314dccf69c6c9dbab 100644 (file)
--- a/src/order.c
+++ b/src/order.c
@@ -1 +1,29 @@
 #include "order.h"
 #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 b164a11bb651b5903ecf38faedf63d848702304a..08bc2a776e2c82a454fa1c6c746ec8736aeb82a6 100644 (file)
--- a/src/order.h
+++ b/src/order.h
@@ -2,7 +2,14 @@
 #define ORDER_H
 #include "classlist.h"
 #include "mymemory.h"
 #define ORDER_H
 #include "classlist.h"
 #include "mymemory.h"

-
+#include "structs.h"
+#include "ops.h"

 struct Order {
 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
 #endif

diff --git a/src/predicate.c b/src/predicate.c
index dcec97af1dbd2b13a997a244cfc6bbecf8a1b10c..2beef617d2c5ec9a5b1dee7c7289ccd79c14d14a 100644 (file)
--- a/src/predicate.c
+++ b/src/predicate.c
@@ -1 +1,12 @@
 #include "predicate.h"
 #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 9a1766962392fc36c70c9a9427792481b204cd3e..06c54bb21f02d457ea50622df6b31f7547051709 100644 (file)
--- a/src/predicate.h
+++ b/src/predicate.h
@@ -2,8 +2,14 @@
 #define PREDICATE_H
 #include "classlist.h"
 #include "mymemory.h"
 #define PREDICATE_H
 #include "classlist.h"
 #include "mymemory.h"

+#include "ops.h"
+#include "structs.h"

 
 struct Predicate {
 
 struct Predicate {

-
+    enum CompOp op;
+    VectorSet* domains;

 };
 };

+
+
+Predicate* allocPredicate(enum CompOp op, Set ** domain, uint numDomain);

 #endif
 #endif