Esempio n. 1
0
File: tbl.c Progetto: dbunker/SABR
void stdInfraTrans(rootData *rdata,indexList *varList,linkedList clauseList,linkedList fullTransNodes,int allowBlankTrans){
	
	int i,n;

	// at most, least one trans/stage
	int transWidth = sizeLinked(fullTransNodes);
	tempTransVar **transArray = toArrayLinked(fullTransNodes);

	// can have an empty state with zero transitions	
	// at most one

	for(n=0;n<numStagesGlobal-1;n++){

        linkedList *lockedTransList = createLinked(Malloc,Free);
		linkedList *transList = createLinked(Malloc,Free);
		
		for(i=0;i<transWidth;i++){
			
			tempTransVar *tv = transArray[i];
			int desObjId = tv->desObjId;
			int transId = tv->transId;
			nodeStages *stages = tv->stages;
            
			// stages are inclusive between start and end for both
			int start = stages->start;
			int end = stages->end;
			
			if(n<start || n>=end-1)
				continue;
		
			varData *var = getTransVar(varList,transId,desObjId,n);
			assert(var,"Trans Failed");
			
			// multiple transitions can happen simultaneously, so don't 
			// need to be in atMostOne
			if(!(tv->isSim))
			    addTailLinked(transList,var);
			
			// if it is locked, atLeastOne Trans must occur
			if(tv->isLocked)
			    addTailLinked(lockedTransList,var);
		}
		
		if(!allowBlankTrans)
			atLeastOne(transList,clauseList);
			
		if(sizeLinked(lockedTransList) > 0)
		    atLeastOne(lockedTransList,clauseList);

		// possible to have a stage with no trans if allowBlankTrans is 0
		atMostOne(transList,clauseList);
		
		destroyLinked(transList,NULL);
		destroyLinked(lockedTransList,NULL);
	}
}
Esempio n. 2
0
File: tbl.c Progetto: dbunker/SABR
void infraClauses(rootData *rdata,indexList *varList,linkedList clauseList,linkedList fullTransNodes,int allowAdvTrans,int allowBlankTrans){

	int y,x,i,n;
	
	// clauses from infrastructure
	// at most, least one symbol/cell/stage
	treeNode *boardNode = rdata->boardNode;
	setData *boardSet = boardNode->data;
	
	int boardWidth = boardSet->width;
	int boardHeight = boardSet->height;
	cellData **boardVars = boardSet->setVars;
	
	for(y=0;y<boardHeight;y++){
		for(x=0;x<boardWidth;x++){

			if(!boardVars[y*boardWidth + x])
				continue;

			cellData *cell = boardVars[y*boardWidth + x];
			linkedList symList = cell->symList;
			int symWidth = sizeLinked(symList);
			int **symArray = toArrayLinked(symList);

			for(n=0;n<numStagesGlobal;n++){
			
				if(symWidth > 2){
				
					// at least, most one variable
					linkedList newVarList = createLinked(Malloc,Free);
					for(i=0;i<symWidth;i++){
						int symId = *symArray[i];
						varData *var = getSymCellVar(varList,x,y,symId,n);
						assert(var,"Var Failed");
						addTailLinked(newVarList,var);
					}
				
					atLeastOne(newVarList,clauseList);
					atMostOne(newVarList,clauseList);
					destroyLinked(newVarList,NULL);
				}
			}
		}
	}
	
	// in cases where there are a lot of trans, it is faster to change the way at-most-one 
	// is performed to matching each to the equivalent of a binary number (series of TransPartVar)
	int transWidth = sizeLinked(fullTransNodes);
	
	if(transWidth > 64 && allowAdvTrans)
		advInfraTrans(rdata,varList,clauseList,fullTransNodes);
	else
		stdInfraTrans(rdata,varList,clauseList,fullTransNodes,allowBlankTrans);
}
Esempio n. 3
0
/************************** operatorHandling ***********************************
Element operatorHandling(Element *pOperand1, Element *pOperand2, Element *pOperator, Customer *pCustomer)
Purpose:
    This function handles an operation of type AND, OR, =, NOTANY, or ONLY on 
    two operands.
Parameters:
    I Element *pOperand1    The first of the two operands.
    I Element *pOperand2    The second operand.
    I Element *pOperator    The operator element for this operation.
    I Customer *pCustomer   The customer for which the operations need to be true.
Notes:
Return value:
    A boolean Element containing the result of the operation.
*******************************************************************************/
Element operatorHandling(Element *pOperand1, Element *pOperand2, Element *pOperator, Customer *pCustomer)
{
    Element result;
    Trait currentTrait;
	
    char *szOperatorM[] = {"=", "NOTANY", "ONLY", "AND", "OR"};
    int i;	
    for (i = 0; (strcmp(pOperator->szToken, szOperatorM[i]) != 0); i++);
    //will stop when i = the index of our operator in szOperatorM[]
	
    switch (i)
    {
        case 0: //=
	    strcpy(currentTrait.szTraitType, pOperand1->szToken);
	    strcpy(currentTrait.szTraitValue, pOperand2->szToken);
	    //store both tokens poped in a trait variable to use in atLeastOne function
	    result.bInclude = atLeastOne(pCustomer, &currentTrait);
	    break;
		
	case 1:	//NOTANY
	    strcpy(currentTrait.szTraitType, pOperand1->szToken);
	    strcpy(currentTrait.szTraitValue, pOperand2->szToken);
	    //store both tokens poped in a trait variable to use in notAny function
	    result.bInclude = notAny(pCustomer, &currentTrait);
	    break;
		
	case 2: //ONLY
	    strcpy(currentTrait.szTraitType, pOperand1->szToken);
	    strcpy(currentTrait.szTraitValue, pOperand2->szToken);
	    //store both tokens poped in a trait variable to use in only function
	    result.bInclude = only(pCustomer, &currentTrait);
	    break;
		
	case 3: //AND
	    result.bInclude = and(pOperand1, pOperand2);
	    //call function and if token is AND
	    break;
		
	case 4: //OR
	    result.bInclude = or(pOperand1, pOperand2);
	    //call function or if token is OR
	    break;
    }	
					
    strcpy(result.szBoolean, "Boolean result of ");
    strcat(result.szBoolean, pOperator->szToken);
    //for help in debugging and identifying boolean structs
                  
    return result;
}
Esempio n. 4
0
/******************************** only *****************************************
int only(Customer *pCustomer, Trait *pTrait)
Purpose:
    Determines whether a customer has a particular trait (type and
    value) and no other trait of the same type. If he does, only 
    returns TRUE; otherwise, it returns FALSE.
Parameters:
    I Customer pCustomer     One customer structure which also
                             contains traits of that customer.
    I Trait    pTrait        The trait that we want this 
                             customer to have.
Notes:
Return value:
    TRUE - customer has the specified trait and no other trait 
    of the same type
    FALSE - customer didn't have the trait and/or had other 
    traits of the same type
*******************************************************************************/
int only(Customer *pCustomer, Trait *pTrait)
{
    if (atLeastOne(pCustomer, pTrait)) //if the customer has the trait
    {
        int i;
        for (i = 0; i < pCustomer->iNumberOfTraits; i++) //go through the customer's trait
        {
            if (strcmp(pCustomer->traitM[i].szTraitType, pTrait->szTraitType) == 0 
                && strcmp(pCustomer->traitM[i].szTraitValue, pTrait->szTraitValue) != 0)
            {
                //if we find a trait of same type but different value
                return FALSE;
            }
        }
        return TRUE;
    }
    return FALSE;
}
Esempio n. 5
0
File: tbl.c Progetto: dbunker/SABR
void reqOptClauses(rootData *rdata,indexList *varList,linkedList clauseList){

	// req
	reqOptClausesInit(reqType,rdata->reqNodes,rdata->desObjNodes,varList,clauseList,NULL);
	
	// opt
	linkedList optGroupList = createLinked(Malloc,Free);
	reqOptClausesInit(optType,rdata->optNodes,rdata->desObjNodes,varList,clauseList,optGroupList);
	
	// add that at least one of each opt group must be true
	int optGroupSize = sizeLinked(optGroupList);
	optGroup **optGroupArray = toArrayLinked(optGroupList);	
	
	// desObj
	linkedList desObjNodes = rdata->desObjNodes;
	int desObjSize = sizeLinked(desObjNodes);
	treeNode **desObjArray = toArrayLinked(desObjNodes);
	
	// at least one Opt-<Opt>-<Any Number>-DesObj-<DesObj>-Stage<Stage>
	int n,i,c,x;
	for(n=0;n<numStagesGlobal;n++){
		
		for(x=0;x<optGroupSize;x++){

			optGroup *optGroup = optGroupArray[x];
			int optGroupObj = optGroup->objId;
			int optGroupName = optGroup->nameId;

			int optSize = sizeLinked(optGroup->list);
			treeNode **optArray = toArrayLinked(optGroup->list);

			for(c=0;c<desObjSize;c++){
			
				treeNode *desObjNode = desObjArray[c];
				nameData *desObjData = desObjNode->data;
			
				int desObjName = desObjData->nameId;
				int desObjObj = desObjData->objId;
			
				if(desObjObj != optGroupObj)
					continue;
				
				linkedList atLeastList = createLinked(Malloc,Free);
				for(i=0;i<optSize;i++){
					treeNode *optNode = optArray[i];

					// check if is valid at this stage
					nodeStages *stages = optNode->stages;
					if(n < stages->start || n > stages->end)
						continue;

					nameData *optData = optNode->data;
					int optNum = optData->elabNum;
					
					// if it was not created, it is not used and so is not needed in atLeastList
					varData *opt = getOptVar(varList,optGroupName,optNum,desObjName,n);
					if(!opt)
						continue;
				
					pushLinked(atLeastList,opt);
				}
				atLeastOne(atLeastList,clauseList);
				destroyLinked(atLeastList,NULL);
			}
		}
	}

	optGroup *rem;
	while((rem = popLinked(optGroupList))){
		destroyLinked(rem->list,NULL);
		Free(rem);
	}
	destroyLinked(optGroupList,NULL);
}
Esempio n. 6
0
File: tbl.c Progetto: dbunker/SABR
// for all distinct variables
void allDifClauses(rootData *rdata,indexList *varList,linkedList clauseList){
	
	int n,c,s,x,y;
	linkedList allDifNodes = rdata->allDifNodes;
	
	int allDifWidth = sizeLinked(allDifNodes);
	treeNode **allDifArray = toArrayLinked(allDifNodes);

	for(n=0;n<numStagesGlobal;n++){
	
		for(c=0;c<allDifWidth;c++){
		
			treeNode *allDifNode = allDifArray[c];
			nameData *allDifData = allDifNode->data;
			
			nodeStages *stages = allDifNode->stages;
			
			if(stages != NULL){
				// stages are inclusive between start and end for both
				int start = stages->start;
				int end = stages->end;
			
				if(n < start || n > end)
					continue;
			}
			
			setData *allDifSet = allDifData->set;
			manyData **many = allDifSet->setVars;
			
			int height = allDifSet->height;
			int width = allDifSet->width;
			
			if(width == 0)
				return;
			
			// these should all have the same symlist
			manyData *manyThis = many[0];
			linkedList symList = manyThis->symList;
			
			int symWidth = sizeLinked(symList);
			int **symArray = toArrayLinked(symList);
			
			for(s=0;s<symWidth;s++){
			
				int symId = *symArray[s];
				
				// must be exactly one
				linkedList singleVars = createLinked(Malloc,Free);
				
				int numCells = 0;
				for(y=0;y<height;y++){
					for(x=0;x<width;x++){
						
						manyThis = many[width*y+x];
						
						// may not have rectangle shape
						if(!manyThis)
							continue;
						
						assertBool(manyThis->symList == symList,"SymList Did Not Match.");
						
						linkedList brackVars = manyThis->brackVars;
						int *boardCellP = peekLinked(brackVars);
						int boardCell = *boardCellP;
						
						varData *v = getSymCellVarByName(varList,boardCell,symId,n);
						assert(v,"AllDif Variable Not Found.");
						
						addTailLinked(singleVars,v);
						numCells++;
					}
				}
				
				atMostOne(singleVars,clauseList);
				
				if(numCells == symWidth)
					atLeastOne(singleVars,clauseList);
				
				destroyLinked(singleVars,NULL);
			}
		}
	}
}