|
|
/**
@file
@ingroup cudd
@brief Application interface functions.
@author Fabio Somenzi
@copyright@parblock Copyright (c) 1995-2015, Regents of the University of Colorado
All rights reserved.
Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
Neither the name of the University of Colorado nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. @endparblock
*/
#include "util.h"
#include "mtrInt.h"
#include "cuddInt.h"
/*---------------------------------------------------------------------------*//* Constant declarations *//*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*//* Stucture declarations *//*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*//* Type declarations *//*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*//* Variable declarations *//*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*//* Macro declarations *//*---------------------------------------------------------------------------*/
/** \cond */
/*---------------------------------------------------------------------------*//* Static function prototypes *//*---------------------------------------------------------------------------*/
static void fixVarTree (MtrNode *treenode, int *perm, int size);static int addMultiplicityGroups (DdManager *dd, MtrNode *treenode, int multiplicity, char *vmask, char *lmask);
/** \endcond */
/*---------------------------------------------------------------------------*//* Definition of exported functions *//*---------------------------------------------------------------------------*/
/**
@brief Returns a new %ADD variable.
@details The new variable has an index equal to the largest previous index plus 1. An %ADD variable differs from a %BDD variable because it points to the arithmetic zero, instead of having a complement pointer to 1.
@return a pointer to the new variable if successful; NULL otherwise.
@sideeffect None
@see Cudd_bddNewVar Cudd_addIthVar Cudd_addConst Cudd_addNewVarAtLevel
*/DdNode *Cudd_addNewVar( DdManager * dd){ DdNode *res;
if ((unsigned int) dd->size >= CUDD_MAXINDEX - 1) { dd->errorCode = CUDD_INVALID_ARG; return(NULL); } do { dd->reordered = 0; res = cuddUniqueInter(dd,dd->size,DD_ONE(dd),DD_ZERO(dd)); } while (dd->reordered == 1); if (dd->errorCode == CUDD_TIMEOUT_EXPIRED && dd->timeoutHandler) { dd->timeoutHandler(dd, dd->tohArg); }
return(res);
} /* end of Cudd_addNewVar */
/**
@brief Returns a new %ADD variable at a specified level.
@details The new variable has an index equal to the largest previous index plus 1 and is positioned at the specified level in the order.
@return a pointer to the new variable if successful; NULL otherwise.
@sideeffect None
@see Cudd_addNewVar Cudd_addIthVar Cudd_bddNewVarAtLevel
*/DdNode *Cudd_addNewVarAtLevel( DdManager * dd, int level){ DdNode *res;
if ((unsigned int) dd->size >= CUDD_MAXINDEX - 1) { dd->errorCode = CUDD_INVALID_ARG; return(NULL); } if (level >= dd->size) return(Cudd_addIthVar(dd,level)); if (!cuddInsertSubtables(dd,1,level)) return(NULL); do { dd->reordered = 0; res = cuddUniqueInter(dd,dd->size - 1,DD_ONE(dd),DD_ZERO(dd)); } while (dd->reordered == 1); if (dd->errorCode == CUDD_TIMEOUT_EXPIRED && dd->timeoutHandler) { dd->timeoutHandler(dd, dd->tohArg); }
return(res);
} /* end of Cudd_addNewVarAtLevel */
/**
@brief Returns a new %BDD variable.
@details The new variable has an index equal to the largest previous index plus 1.
@return a pointer to the new variable if successful; NULL otherwise.
@sideeffect None
@see Cudd_addNewVar Cudd_bddIthVar Cudd_bddNewVarAtLevel
*/DdNode *Cudd_bddNewVar( DdManager * dd){ DdNode *res;
if ((unsigned int) dd->size >= CUDD_MAXINDEX - 1) { dd->errorCode = CUDD_INVALID_ARG; return(NULL); } res = cuddUniqueInter(dd,dd->size,dd->one,Cudd_Not(dd->one));
return(res);
} /* end of Cudd_bddNewVar */
/**
@brief Returns a new %BDD variable at a specified level.
@details The new variable has an index equal to the largest previous index plus 1 and is positioned at the specified level in the order.
@return a pointer to the new variable if successful; NULL otherwise.
@sideeffect None
@see Cudd_bddNewVar Cudd_bddIthVar Cudd_addNewVarAtLevel
*/DdNode *Cudd_bddNewVarAtLevel( DdManager * dd, int level){ DdNode *res;
if ((unsigned int) dd->size >= CUDD_MAXINDEX - 1) { dd->errorCode = CUDD_INVALID_ARG; return(NULL); } if (level >= dd->size) return(Cudd_bddIthVar(dd,level)); if (!cuddInsertSubtables(dd,1,level)) return(NULL); res = dd->vars[dd->size - 1];
return(res);
} /* end of Cudd_bddNewVarAtLevel */
/**
@brief Returns 1 if the given node is a %BDD variable; 0 otherwise.
@sideeffect None
*/intCudd_bddIsVar( DdManager * dd, DdNode * f){ DdNode *one = DD_ONE(dd); return(f != 0 && cuddT(f) == one && cuddE(f) == Cudd_Not(one));
} /* end of Cudd_bddIsVar */
/**
@brief Returns the %ADD variable with index i.
@details Retrieves the %ADD variable with index i if it already exists, or creates a new %ADD variable. An %ADD variable differs from a %BDD variable because it points to the arithmetic zero, instead of having a complement pointer to 1.
@return a pointer to the variable if successful; NULL otherwise.
@sideeffect None
@see Cudd_addNewVar Cudd_bddIthVar Cudd_addConst Cudd_addNewVarAtLevel
*/DdNode *Cudd_addIthVar( DdManager * dd, int i){ DdNode *res;
if ((unsigned int) i >= CUDD_MAXINDEX - 1) { dd->errorCode = CUDD_INVALID_ARG; return(NULL); } do { dd->reordered = 0; res = cuddUniqueInter(dd,i,DD_ONE(dd),DD_ZERO(dd)); } while (dd->reordered == 1); if (dd->errorCode == CUDD_TIMEOUT_EXPIRED && dd->timeoutHandler) { dd->timeoutHandler(dd, dd->tohArg); }
return(res);
} /* end of Cudd_addIthVar */
/**
@brief Returns the %BDD variable with index i.
@details Retrieves the %BDD variable with index i if it already exists, or creates a new %BDD variable.
@return a pointer to the variable if successful; NULL otherwise.
@sideeffect None
@see Cudd_bddNewVar Cudd_addIthVar Cudd_bddNewVarAtLevel Cudd_ReadVars
*/DdNode *Cudd_bddIthVar( DdManager * dd, int i){ DdNode *res;
if ((unsigned int) i >= CUDD_MAXINDEX - 1) { dd->errorCode = CUDD_INVALID_ARG; return(NULL); } if (i < dd->size) { res = dd->vars[i]; } else { res = cuddUniqueInter(dd,i,dd->one,Cudd_Not(dd->one)); }
return(res);
} /* end of Cudd_bddIthVar */
/**
@brief Returns the %ZDD variable with index i.
@details Retrieves the %ZDD variable with index i if it already exists, or creates a new %ZDD variable.
@return a pointer to the variable if successful; NULL otherwise.
@sideeffect None
@see Cudd_bddIthVar Cudd_addIthVar
*/DdNode *Cudd_zddIthVar( DdManager * dd, int i){ DdNode *res; DdNode *zvar; DdNode *lower; int j;
if ((unsigned int) i >= CUDD_MAXINDEX - 1) { dd->errorCode = CUDD_INVALID_ARG; return(NULL); } /* The i-th variable function has the following structure:
** at the level corresponding to index i there is a node whose "then" ** child points to the universe, and whose "else" child points to zero. ** Above that level there are nodes with identical children. */
/* First we build the node at the level of index i. */ lower = (i < dd->sizeZ - 1) ? dd->univ[dd->permZ[i]+1] : DD_ONE(dd); do { dd->reordered = 0; zvar = cuddUniqueInterZdd(dd, i, lower, DD_ZERO(dd)); } while (dd->reordered == 1); if (dd->errorCode == CUDD_TIMEOUT_EXPIRED && dd->timeoutHandler) { dd->timeoutHandler(dd, dd->tohArg); }
if (zvar == NULL) return(NULL); cuddRef(zvar);
/* Now we add the "filler" nodes above the level of index i. */ for (j = dd->permZ[i] - 1; j >= 0; j--) { do { dd->reordered = 0; res = cuddUniqueInterZdd(dd, dd->invpermZ[j], zvar, zvar); } while (dd->reordered == 1); if (res == NULL) { Cudd_RecursiveDerefZdd(dd,zvar); if (dd->errorCode == CUDD_TIMEOUT_EXPIRED && dd->timeoutHandler) { dd->timeoutHandler(dd, dd->tohArg); } return(NULL); } cuddRef(res); Cudd_RecursiveDerefZdd(dd,zvar); zvar = res; } cuddDeref(zvar); return(zvar);
} /* end of Cudd_zddIthVar */
/**
@brief Creates one or more %ZDD variables for each %BDD variable.
@details If some %ZDD variables already exist, only the missing variables are created. Parameter multiplicity allows the caller to control how many variables are created for each %BDD variable in existence. For instance, if ZDDs are used to represent covers, two %ZDD variables are required for each %BDD variable. The order of the %BDD variables is transferred to the %ZDD variables. If a variable group tree exists for the %BDD variables, a corresponding %ZDD variable group tree is created by expanding the %BDD variable tree. In any case, the %ZDD variables derived from the same %BDD variable are merged in a %ZDD variable group. If a %ZDD variable group tree exists, it is freed.
@return 1 if successful; 0 otherwise.
@sideeffect None
@see Cudd_bddNewVar Cudd_bddIthVar Cudd_bddNewVarAtLevel
*/intCudd_zddVarsFromBddVars( DdManager * dd /**< %DD manager */, int multiplicity /**< how many %ZDD variables are created for each %BDD variable */){ int res; int i, j; int allnew; int *permutation;
if (multiplicity < 1) { dd->errorCode = CUDD_INVALID_ARG; return(0); } allnew = dd->sizeZ == 0; if (dd->size * multiplicity > dd->sizeZ) { res = cuddResizeTableZdd(dd,dd->size * multiplicity - 1); if (res == 0) return(0); } /* Impose the order of the BDD variables to the ZDD variables. */ if (allnew) { for (i = 0; i < dd->size; i++) { for (j = 0; j < multiplicity; j++) { dd->permZ[i * multiplicity + j] = dd->perm[i] * multiplicity + j; dd->invpermZ[dd->permZ[i * multiplicity + j]] = i * multiplicity + j; } } for (i = 0; i < dd->sizeZ; i++) { dd->univ[i]->index = dd->invpermZ[i]; } } else { permutation = ALLOC(int,dd->sizeZ); if (permutation == NULL) { dd->errorCode = CUDD_MEMORY_OUT; return(0); } for (i = 0; i < dd->size; i++) { for (j = 0; j < multiplicity; j++) { permutation[i * multiplicity + j] = dd->invperm[i] * multiplicity + j; } } for (i = dd->size * multiplicity; i < dd->sizeZ; i++) { permutation[i] = i; } res = Cudd_zddShuffleHeap(dd, permutation); FREE(permutation); if (res == 0) return(0); } /* Copy and expand the variable group tree if it exists. */ if (dd->treeZ != NULL) { Cudd_FreeZddTree(dd); } if (dd->tree != NULL) { dd->treeZ = Mtr_CopyTree(dd->tree, multiplicity); if (dd->treeZ == NULL) return(0); } else if (multiplicity > 1) { dd->treeZ = Mtr_InitGroupTree(0, dd->sizeZ); if (dd->treeZ == NULL) return(0); dd->treeZ->index = dd->invpermZ[0]; } /* Create groups for the ZDD variables derived from the same BDD variable.
*/ if (multiplicity > 1) { char *vmask, *lmask;
vmask = ALLOC(char, dd->size); if (vmask == NULL) { dd->errorCode = CUDD_MEMORY_OUT; return(0); } lmask = ALLOC(char, dd->size); if (lmask == NULL) { dd->errorCode = CUDD_MEMORY_OUT; return(0); } for (i = 0; i < dd->size; i++) { vmask[i] = lmask[i] = 0; } res = addMultiplicityGroups(dd,dd->treeZ,multiplicity,vmask,lmask); FREE(vmask); FREE(lmask); if (res == 0) return(0); } return(1);
} /* end of Cudd_zddVarsFromBddVars */
/**
@brief Returns the maximum possible index for a variable.
@sideeffect None*/unsigned intCudd_ReadMaxIndex(void){ return(CUDD_MAXINDEX);
} /* end of Cudd_ReadMaxIndex */
/**
@brief Returns the %ADD for constant c.
@details Retrieves the %ADD for constant c if it already exists, or creates a new %ADD.
@return a pointer to the %ADD if successful; NULL otherwise.
@sideeffect None
@see Cudd_addNewVar Cudd_addIthVar
*/DdNode *Cudd_addConst( DdManager * dd, CUDD_VALUE_TYPE c){ return(cuddUniqueConst(dd,c));
} /* end of Cudd_addConst */
/**
@brief Returns 1 if the node is a constant node.
@details A constant node is not an internal node. The pointer passed to Cudd_IsConstant may be either regular or complemented.
@sideeffect none
*/int Cudd_IsConstant(DdNode *node){ return Cudd_Regular(node)->index == CUDD_CONST_INDEX;
} /* end of Cudd_IsConstant */
/**
@brief Returns 1 if a %DD node is not constant.
@details This function is useful to test the results of Cudd_bddIteConstant, Cudd_addIteConstant, Cudd_addEvalConst. These results may be a special value signifying non-constant. In the other cases Cudd_IsConstant can be used.
@sideeffect None
@see Cudd_IsConstant Cudd_bddIteConstant Cudd_addIteConstant Cudd_addEvalConst
*/intCudd_IsNonConstant( DdNode *f){ return(f == DD_NON_CONSTANT || !Cudd_IsConstantInt(f));
} /* end of Cudd_IsNonConstant */
/**
@brief Returns the then child of an internal node.
@details If <code>node</code> is a constant node, the result is unpredictable.
@sideeffect none
@see Cudd_E Cudd_V
*/DdNode const *Cudd_T_const(DdNode const *node){ return Cudd_Regular(node)->type.kids.T;
} /* end of Cudd_T */
/**
@brief Returns the else child of an internal node.
@details If <code>node</code> is a constant node, the result is unpredictable.
@sideeffect none
@see Cudd_T Cudd_V
*/DdNode const *Cudd_E_const(DdNode const * node){ return Cudd_Regular(node)->type.kids.E;
} /* end of Cudd_E */
/**
@brief Returns the then child of an internal node. @details If <code>node</code> is a constant node, the result is unpredictable. @sideeffect none @see Cudd_E Cudd_V */DdNode *Cudd_T(DdNode * node){ return Cudd_Regular(node)->type.kids.T; } /* end of Cudd_T */
/**
@brief Returns the else child of an internal node. @details If <code>node</code> is a constant node, the result is unpredictable. @sideeffect none @see Cudd_T Cudd_V */DdNode *Cudd_E(DdNode * node){ return Cudd_Regular(node)->type.kids.E; } /* end of Cudd_E */
/**
@brief Returns the value of a constant node.
@details If <code>node</code> is an internal node, the result is unpredictable.
@sideeffect none
@see Cudd_T Cudd_E
*/CUDD_VALUE_TYPECudd_V(DdNode const *node){ return Cudd_Regular(node)->type.value;
} /* end of Cudd_V */
/**
@brief Returns the start time of the manager.
@details This is initially set to the number of milliseconds since the program started, but may be reset by the application.
@sideeffect None
@see Cudd_SetStartTime Cudd_ResetStartTime Cudd_ReadTimeLimit
*/unsigned longCudd_ReadStartTime( DdManager * unique){ return unique->startTime;
} /* end of Cudd_ReadStartTime */
/**
@brief Returns the time elapsed since the start time of the manager.
@details The time is expressed in milliseconds.
@sideeffect None
@see Cudd_ReadStartTime Cudd_SetStartTime
*/unsigned longCudd_ReadElapsedTime( DdManager * unique){ return util_cpu_time() - unique->startTime;
} /* end of Cudd_ReadElapsedTime */
/**
@brief Sets the start time of the manager.
@details The time must be expressed in milliseconds.
@sideeffect None
@see Cudd_ReadStartTime Cudd_ResetStartTime Cudd_ReadElapsedTime Cudd_SetTimeLimit
*/voidCudd_SetStartTime( DdManager * unique, unsigned long st){ unique->startTime = st;
} /* end of Cudd_SetStartTime */
/**
@brief Resets the start time of the manager.
@sideeffect None
@see Cudd_ReadStartTime Cudd_SetStartTime Cudd_SetTimeLimit
*/voidCudd_ResetStartTime( DdManager * unique){ unique->startTime = util_cpu_time();
} /* end of Cudd_ResetStartTime */
/**
@brief Returns the time limit for the manager.
@details This is initially set to a very large number, but may be reset by the application. The time is expressed in milliseconds.
@sideeffect None
@see Cudd_SetTimeLimit Cudd_UpdateTimeLimit Cudd_UnsetTimeLimit Cudd_IncreaseTimeLimit Cudd_TimeLimited Cudd_ReadStartTime
*/unsigned longCudd_ReadTimeLimit( DdManager * unique){ return unique->timeLimit;
} /* end of Cudd_ReadTimeLimit */
/**
@brief Sets the time limit for the manager.
@details The time must be expressed in milliseconds.
@return the old time limit.
@sideeffect None
@see Cudd_ReadTimeLimit Cudd_UnsetTimeLimit Cudd_UpdateTimeLimit Cudd_IncreaseTimeLimit Cudd_TimeLimited Cudd_SetStartTime
*/unsigned longCudd_SetTimeLimit( DdManager * unique, unsigned long tl){ unsigned long ret = unique->timeLimit; unique->timeLimit = tl; return(ret);
} /* end of Cudd_SetTimeLimit */
/**
@brief Updates the time limit for the manager.
@details Updates the time limit for the manager by subtracting the elapsed time from it.
@sideeffect None
@see Cudd_ReadTimeLimit Cudd_SetTimeLimit Cudd_UnsetTimeLimit Cudd_IncreaseTimeLimit Cudd_TimeLimited Cudd_SetStartTime
*/voidCudd_UpdateTimeLimit( DdManager * unique){ unsigned long elapsed; if (unique->timeLimit == ~0UL) return; elapsed = util_cpu_time() - unique->startTime; if (unique->timeLimit >= elapsed) { unique->timeLimit -= elapsed; } else { unique->timeLimit = 0; }
} /* end of Cudd_UpdateTimeLimit */
/**
@brief Increases the time limit for the manager.
@details The time increase must be expressed in milliseconds.
@sideeffect None
@see Cudd_ReadTimeLimit Cudd_SetTimeLimit Cudd_UnsetTimeLimit Cudd_UpdateTimeLimit Cudd_TimeLimited Cudd_SetStartTime
*/voidCudd_IncreaseTimeLimit( DdManager * unique, unsigned long increase){ if (unique->timeLimit == ~0UL) unique->timeLimit = increase; else unique->timeLimit += increase;
} /* end of Cudd_IncreaseTimeLimit */
/**
@brief Unsets the time limit for the manager.
@details Actually, sets it to a very large value.
@sideeffect None
@see Cudd_ReadTimeLimit Cudd_SetTimeLimit Cudd_UpdateTimeLimit Cudd_IncreaseTimeLimit Cudd_TimeLimited Cudd_SetStartTime
*/voidCudd_UnsetTimeLimit( DdManager * unique){ unique->timeLimit = ~0UL;
} /* end of Cudd_UnsetTimeLimit */
/**
@brief Returns true if the time limit for the manager is set.
@sideeffect None
@see Cudd_ReadTimeLimit Cudd_SetTimeLimit Cudd_UpdateTimeLimit Cudd_UnsetTimeLimit Cudd_IncreaseTimeLimit
*/intCudd_TimeLimited( DdManager * unique){ return unique->timeLimit != ~0UL;
} /* end of Cudd_TimeLimited */
/**
@brief Installs a termination callback.
@details Registers a callback function that is called from time to time to decide whether computation should be abandoned.
@sideeffect None
@see Cudd_UnregisterTerminationCallback
*/voidCudd_RegisterTerminationCallback( DdManager *unique, DD_THFP callback, void * callback_arg){ unique->terminationCallback = callback; unique->tcbArg = callback_arg;
} /* end of Cudd_RegisterTerminationCallback */
/**
@brief Unregisters a termination callback.
@sideeffect None
@see Cudd_RegisterTerminationCallback
*/voidCudd_UnregisterTerminationCallback( DdManager *unique){ unique->terminationCallback = NULL; unique->tcbArg = NULL;
} /* end of Cudd_UnregisterTerminationCallback */
/**
@brief Installs an out-of-memory callback.
@details Registers a callback function that is called when a discretionary memory allocation fails.
@return the old callback function.
@sideeffect None
@see Cudd_UnregisterOutOfMemoryCallback Cudd_OutOfMem Cudd_OutOfMemSilent
*/DD_OOMFPCudd_RegisterOutOfMemoryCallback( DdManager *unique, DD_OOMFP callback){ DD_OOMFP ret = unique->outOfMemCallback; unique->outOfMemCallback = callback; return(ret);
} /* end of Cudd_RegisterOutOfMemoryCallback */
/**
@brief Unregister an out-of-memory callback.
@sideeffect None
@see Cudd_RegisterOutOfMemoryCallback Cudd_OutOfMem Cudd_OutOfMemSilent
*/voidCudd_UnregisterOutOfMemoryCallback( DdManager *unique){ unique->outOfMemCallback = Cudd_OutOfMemSilent;
} /* end of Cudd_UnregisterOutOfMemoryCallback */
/**
@brief Register a timeout handler function.
@details To unregister a handler, register a NULL pointer.
@sideeffect None
@see Cudd_ReadTimeoutHandler*/voidCudd_RegisterTimeoutHandler( DdManager *unique, DD_TOHFP handler, void *arg){ unique->timeoutHandler = handler; unique->tohArg = arg;
} /* end of Cudd_RegisterTimeoutHandler */
/**
@brief Read the current timeout handler function.
@sideeffect If argp is non-null, the second argument to the handler is written to the location it points to.
@see Cudd_RegisterTimeoutHandler*/DD_TOHFPCudd_ReadTimeoutHandler( DdManager *unique, void **argp){ if (argp != NULL) *argp = unique->tohArg; return unique->timeoutHandler;
} /* end of Cudd_ReadTimeoutHandler */
/**
@brief Enables automatic dynamic reordering of BDDs and ADDs.
@details Parameter method is used to determine the method used for reordering. If CUDD_REORDER_SAME is passed, the method is unchanged.
@sideeffect None
@see Cudd_AutodynDisable Cudd_ReorderingStatus Cudd_AutodynEnableZdd
*/voidCudd_AutodynEnable( DdManager * unique, Cudd_ReorderingType method){ unique->autoDyn = 1; if (method != CUDD_REORDER_SAME) { unique->autoMethod = method; }#ifndef DD_NO_DEATH_ROW
/* If reordering is enabled, using the death row causes too many
** invocations. Hence, we shrink the death row to just one entry. */ cuddClearDeathRow(unique); unique->deathRowDepth = 1; unique->deadMask = unique->deathRowDepth - 1; if ((unsigned) unique->nextDead > unique->deadMask) { unique->nextDead = 0; } unique->deathRow = REALLOC(DdNodePtr, unique->deathRow, unique->deathRowDepth);#endif
return;
} /* end of Cudd_AutodynEnable */
/**
@brief Disables automatic dynamic reordering.
@sideeffect None
@see Cudd_AutodynEnable Cudd_ReorderingStatus Cudd_AutodynDisableZdd
*/voidCudd_AutodynDisable( DdManager * unique){ unique->autoDyn = 0; return;
} /* end of Cudd_AutodynDisable */
/**
@brief Reports the status of automatic dynamic reordering of BDDs and ADDs.
@details The location pointed by parameter method is set to the reordering method currently selected if method is non-null.
@return 1 if automatic reordering is enabled; 0 otherwise.
@sideeffect The location pointed by parameter method is set to the reordering method currently selected if method is non-null.
@see Cudd_AutodynEnable Cudd_AutodynDisable Cudd_ReorderingStatusZdd
*/intCudd_ReorderingStatus( DdManager * unique, Cudd_ReorderingType * method){ if (method) *method = unique->autoMethod; return(unique->autoDyn);
} /* end of Cudd_ReorderingStatus */
/**
@brief Enables automatic dynamic reordering of ZDDs.
@details Parameter method is used to determine the method used for reordering ZDDs. If CUDD_REORDER_SAME is passed, the method is unchanged.
@sideeffect None
@see Cudd_AutodynDisableZdd Cudd_ReorderingStatusZdd Cudd_AutodynEnable
*/voidCudd_AutodynEnableZdd( DdManager * unique, Cudd_ReorderingType method){ unique->autoDynZ = 1; if (method != CUDD_REORDER_SAME) { unique->autoMethodZ = method; } return;
} /* end of Cudd_AutodynEnableZdd */
/**
@brief Disables automatic dynamic reordering of ZDDs.
@sideeffect None
@see Cudd_AutodynEnableZdd Cudd_ReorderingStatusZdd Cudd_AutodynDisable
*/voidCudd_AutodynDisableZdd( DdManager * unique){ unique->autoDynZ = 0; return;
} /* end of Cudd_AutodynDisableZdd */
/**
@brief Reports the status of automatic dynamic reordering of ZDDs.
@details Parameter method is set to the %ZDD reordering method currently selected.
@return 1 if automatic reordering is enabled; 0 otherwise.
@sideeffect Parameter method is set to the %ZDD reordering method currently selected.
@see Cudd_AutodynEnableZdd Cudd_AutodynDisableZdd Cudd_ReorderingStatus
*/intCudd_ReorderingStatusZdd( DdManager * unique, Cudd_ReorderingType * method){ *method = unique->autoMethodZ; return(unique->autoDynZ);
} /* end of Cudd_ReorderingStatusZdd */
/**
@brief Tells whether the realignment of %ZDD order to %BDD order is enabled.
@return 1 if the realignment of %ZDD order to %BDD order is enabled; 0 otherwise.
@sideeffect None
@see Cudd_zddRealignEnable Cudd_zddRealignDisable Cudd_bddRealignEnable Cudd_bddRealignDisable
*/intCudd_zddRealignmentEnabled( DdManager * unique){ return(unique->realign);
} /* end of Cudd_zddRealignmentEnabled */
/**
@brief Enables realignment of %ZDD order to %BDD order.
@details Enables realignment of the %ZDD variable order to the %BDD variable order after the BDDs and ADDs have been reordered. The number of %ZDD variables must be a multiple of the number of %BDD variables for realignment to make sense. If this condition is not met, Cudd_ReduceHeap will return 0. Let <code>M</code> be the ratio of the two numbers. For the purpose of realignment, the %ZDD variables from <code>M*i</code> to <code>(M+1)*i-1</code> are reagarded as corresponding to %BDD variable <code>i</code>. Realignment is initially disabled.
@sideeffect None
@see Cudd_ReduceHeap Cudd_zddRealignDisable Cudd_zddRealignmentEnabled Cudd_bddRealignDisable Cudd_bddRealignmentEnabled
*/voidCudd_zddRealignEnable( DdManager * unique){ unique->realign = 1; return;
} /* end of Cudd_zddRealignEnable */
/**
@brief Disables realignment of %ZDD order to %BDD order.
@sideeffect None
@see Cudd_zddRealignEnable Cudd_zddRealignmentEnabled Cudd_bddRealignEnable Cudd_bddRealignmentEnabled
*/voidCudd_zddRealignDisable( DdManager * unique){ unique->realign = 0; return;
} /* end of Cudd_zddRealignDisable */
/**
@brief Tells whether the realignment of %BDD order to %ZDD order is enabled.
@return 1 if the realignment of %BDD order to %ZDD order is enabled; 0 otherwise.
@sideeffect None
@see Cudd_bddRealignEnable Cudd_bddRealignDisable Cudd_zddRealignEnable Cudd_zddRealignDisable
*/intCudd_bddRealignmentEnabled( DdManager * unique){ return(unique->realignZ);
} /* end of Cudd_bddRealignmentEnabled */
/**
@brief Enables realignment of %BDD order to %ZDD order.
@details Enables realignment of the %BDD variable order to the %ZDD variable order after the ZDDs have been reordered. The number of %ZDD variables must be a multiple of the number of %BDD variables for realignment to make sense. If this condition is not met, Cudd_zddReduceHeap will return 0. Let <code>M</code> be the ratio of the two numbers. For the purpose of realignment, the %ZDD variables from <code>M*i</code> to <code>(M+1)*i-1</code> are reagarded as corresponding to %BDD variable <code>i</code>. Realignment is initially disabled.
@sideeffect None
@see Cudd_zddReduceHeap Cudd_bddRealignDisable Cudd_bddRealignmentEnabled Cudd_zddRealignDisable Cudd_zddRealignmentEnabled
*/voidCudd_bddRealignEnable( DdManager * unique){ unique->realignZ = 1; return;
} /* end of Cudd_bddRealignEnable */
/**
@brief Disables realignment of %ZDD order to %BDD order.
@sideeffect None
@see Cudd_bddRealignEnable Cudd_bddRealignmentEnabled Cudd_zddRealignEnable Cudd_zddRealignmentEnabled
*/voidCudd_bddRealignDisable( DdManager * unique){ unique->realignZ = 0; return;
} /* end of Cudd_bddRealignDisable */
/**
@brief Returns the one constant of the manager.
@details The one constant is common to ADDs and BDDs.
@sideeffect None
@see Cudd_ReadZero Cudd_ReadLogicZero Cudd_ReadZddOne
*/DdNode *Cudd_ReadOne( DdManager * dd){ return(dd->one);
} /* end of Cudd_ReadOne */
/**
@brief Returns the %ZDD for the constant 1 function.
@details The representation of the constant 1 function as a %ZDD depends on how many variables it (nominally) depends on. The index of the topmost variable in the support is given as argument <code>i</code>.
@sideeffect None
@see Cudd_ReadOne
*/DdNode *Cudd_ReadZddOne( DdManager * dd, int i){ if (i < 0) return(NULL); return(i < dd->sizeZ ? dd->univ[i] : DD_ONE(dd));
} /* end of Cudd_ReadZddOne */
/**
@brief Returns the zero constant of the manager.
@details The zero constant is the arithmetic zero, rather than the logic zero. The latter is the complement of the one constant.
@sideeffect None
@see Cudd_ReadOne Cudd_ReadLogicZero
*/DdNode *Cudd_ReadZero( DdManager * dd){ return(DD_ZERO(dd));
} /* end of Cudd_ReadZero */
/**
@brief Returns the logic zero constant of the manager.
@details The logic zero constant is the complement of the one constant, and is distinct from the arithmetic zero.
@sideeffect None
@see Cudd_ReadOne Cudd_ReadZero
*/DdNode *Cudd_ReadLogicZero( DdManager * dd){ return(Cudd_Not(DD_ONE(dd)));
} /* end of Cudd_ReadLogicZero */
/**
@brief Reads the plus-infinity constant from the manager.
@sideeffect None
*/DdNode *Cudd_ReadPlusInfinity( DdManager * dd){ return(dd->plusinfinity);
} /* end of Cudd_ReadPlusInfinity */
/**
@brief Reads the minus-infinity constant from the manager.
@sideeffect None
*/DdNode *Cudd_ReadMinusInfinity( DdManager * dd){ return(dd->minusinfinity);
} /* end of Cudd_ReadMinusInfinity */
/**
@brief Reads the background constant of the manager.
@sideeffect None
*/DdNode *Cudd_ReadBackground( DdManager * dd){ return(dd->background);
} /* end of Cudd_ReadBackground */
/**
@brief Sets the background constant of the manager.
@details It assumes that the DdNode pointer bck is already referenced.
@sideeffect None
*/voidCudd_SetBackground( DdManager * dd, DdNode * bck){ dd->background = bck;
} /* end of Cudd_SetBackground */
/**
@brief Reads the number of slots in the cache.
@sideeffect None
@see Cudd_ReadCacheUsedSlots
*/unsigned intCudd_ReadCacheSlots( DdManager * dd){ return(dd->cacheSlots);
} /* end of Cudd_ReadCacheSlots */
/**
@brief Reads the fraction of used slots in the cache.
@details The unused slots are those in which no valid data is stored. Garbage collection, variable reordering, and cache resizing may cause used slots to become unused.
@sideeffect None
@see Cudd_ReadCacheSlots
*/doubleCudd_ReadCacheUsedSlots( DdManager * dd){ size_t used = 0; int slots = dd->cacheSlots; DdCache *cache = dd->cache; int i;
for (i = 0; i < slots; i++) { used += cache[i].h != 0; }
return((double)used / (double) dd->cacheSlots);
} /* end of Cudd_ReadCacheUsedSlots */
/**
@brief Returns the number of cache look-ups.
@sideeffect None
@see Cudd_ReadCacheHits
*/doubleCudd_ReadCacheLookUps( DdManager * dd){ return(dd->cacheHits + dd->cacheMisses + dd->totCachehits + dd->totCacheMisses);
} /* end of Cudd_ReadCacheLookUps */
/**
@brief Returns the number of cache hits.
@sideeffect None
@see Cudd_ReadCacheLookUps
*/doubleCudd_ReadCacheHits( DdManager * dd){ return(dd->cacheHits + dd->totCachehits);
} /* end of Cudd_ReadCacheHits */
/**
@brief Returns the number of recursive calls.
@details Returns the number of recursive calls if the package is compiled with DD_COUNT defined.
@sideeffect None
*/doubleCudd_ReadRecursiveCalls( DdManager * dd){#ifdef DD_COUNT
return(dd->recursiveCalls);#else
(void) dd; /* avoid warning */ return(-1.0);#endif
} /* end of Cudd_ReadRecursiveCalls */
/**
@brief Reads the hit rate that causes resizinig of the computed table.
@sideeffect None
@see Cudd_SetMinHit
*/unsigned intCudd_ReadMinHit( DdManager * dd){ /* Internally, the package manipulates the ratio of hits to
** misses instead of the ratio of hits to accesses. */ return((unsigned int) (0.5 + 100 * dd->minHit / (1 + dd->minHit)));
} /* end of Cudd_ReadMinHit */
/**
@brief Sets the hit rate that causes resizinig of the computed table.
@details Sets the minHit parameter of the manager. This parameter controls the resizing of the computed table. If the hit rate is larger than the specified value, and the cache is not already too large, then its size is doubled.
@sideeffect None
@see Cudd_ReadMinHit
*/voidCudd_SetMinHit( DdManager * dd, unsigned int hr){ /* Internally, the package manipulates the ratio of hits to
** misses instead of the ratio of hits to accesses. */ dd->minHit = (double) hr / (100.0 - (double) hr);
} /* end of Cudd_SetMinHit */
/**
@brief Reads the looseUpTo parameter of the manager.
@sideeffect None
@see Cudd_SetLooseUpTo Cudd_ReadMinHit Cudd_ReadMinDead
*/unsigned intCudd_ReadLooseUpTo( DdManager * dd){ return(dd->looseUpTo);
} /* end of Cudd_ReadLooseUpTo */
/**
@brief Sets the looseUpTo parameter of the manager.
@details This parameter of the manager controls the threshold beyond which no fast growth of the unique table is allowed. The threshold is given as a number of slots. If the value passed to this function is 0, the function determines a suitable value based on the available memory.
@sideeffect None
@see Cudd_ReadLooseUpTo Cudd_SetMinHit
*/voidCudd_SetLooseUpTo( DdManager * dd, unsigned int lut){ if (lut == 0) { unsigned long datalimit = getSoftDataLimit(); lut = (unsigned int) (datalimit / (sizeof(DdNode) * DD_MAX_LOOSE_FRACTION)); } dd->looseUpTo = lut;
} /* end of Cudd_SetLooseUpTo */
/**
@brief Returns the soft limit for the cache size.
@sideeffect None
@see Cudd_ReadMaxCacheHard
*/unsigned intCudd_ReadMaxCache( DdManager * dd){ return(2 * dd->cacheSlots + dd->cacheSlack);
} /* end of Cudd_ReadMaxCache */
/**
@brief Reads the maxCacheHard parameter of the manager.
@sideeffect None
@see Cudd_SetMaxCacheHard Cudd_ReadMaxCache
*/unsigned intCudd_ReadMaxCacheHard( DdManager * dd){ return(dd->maxCacheHard);
} /* end of Cudd_ReadMaxCache */
/**
@brief Sets the maxCacheHard parameter of the manager.
@details The cache cannot grow larger than maxCacheHard entries. This parameter allows an application to control the trade-off of memory versus speed. If the value passed to this function is 0, the function determines a suitable maximum cache size based on the available memory.
@sideeffect None
@see Cudd_ReadMaxCacheHard Cudd_SetMaxCache
*/voidCudd_SetMaxCacheHard( DdManager * dd, unsigned int mc){ if (mc == 0) { unsigned long datalimit = getSoftDataLimit(); mc = (unsigned int) (datalimit / (sizeof(DdCache) * DD_MAX_CACHE_FRACTION)); } dd->maxCacheHard = mc;
} /* end of Cudd_SetMaxCacheHard */
/**
@brief Returns the number of %BDD variables in existance.
@sideeffect None
@see Cudd_ReadZddSize
*/intCudd_ReadSize( DdManager * dd){ return(dd->size);
} /* end of Cudd_ReadSize */
/**
@brief Returns the number of %ZDD variables in existance.
@sideeffect None
@see Cudd_ReadSize
*/intCudd_ReadZddSize( DdManager * dd){ return(dd->sizeZ);
} /* end of Cudd_ReadZddSize */
/**
@brief Returns the total number of slots of the unique table.
@details This number is mainly for diagnostic purposes.
@sideeffect None
*/unsigned intCudd_ReadSlots( DdManager * dd){ return(dd->slots);
} /* end of Cudd_ReadSlots */
/**
@brief Reads the fraction of used slots in the unique table.
@details The unused slots are those in which no valid data is stored. Garbage collection, variable reordering, and subtable resizing may cause used slots to become unused.
@sideeffect None
@see Cudd_ReadSlots
*/doubleCudd_ReadUsedSlots( DdManager * dd){ size_t used = 0; int i, j; int size = dd->size; DdNodePtr *nodelist; DdSubtable *subtable; DdNode *node; DdNode *sentinel = &(dd->sentinel);
/* Scan each BDD/ADD subtable. */ for (i = 0; i < size; i++) { subtable = &(dd->subtables[i]); nodelist = subtable->nodelist; for (j = 0; (unsigned) j < subtable->slots; j++) { node = nodelist[j]; if (node != sentinel) { used++; } } }
/* Scan the ZDD subtables. */ size = dd->sizeZ;
for (i = 0; i < size; i++) { subtable = &(dd->subtableZ[i]); nodelist = subtable->nodelist; for (j = 0; (unsigned) j < subtable->slots; j++) { node = nodelist[j]; if (node != NULL) { used++; } } }
/* Constant table. */ subtable = &(dd->constants); nodelist = subtable->nodelist; for (j = 0; (unsigned) j < subtable->slots; j++) { node = nodelist[j]; if (node != NULL) { used++; } }
return((double)used / (double) dd->slots);
} /* end of Cudd_ReadUsedSlots */
/**
@brief Computes the expected fraction of used slots in the unique table.
@details This expected value is based on the assumption that the hash function distributes the keys randomly; it can be compared with the result of Cudd_ReadUsedSlots to monitor the performance of the unique table hash function.
@sideeffect None
@see Cudd_ReadSlots Cudd_ReadUsedSlots
*/doubleCudd_ExpectedUsedSlots( DdManager * dd){ int i; int size = dd->size; DdSubtable *subtable; double empty = 0.0;
/* To each subtable we apply the corollary to Theorem 8.5 (occupancy
** distribution) from Sedgewick and Flajolet's Analysis of Algorithms. ** The corollary says that for a table with M buckets and a load ratio ** of r, the expected number of empty buckets is asymptotically given ** by M * exp(-r). */
/* Scan each BDD/ADD subtable. */ for (i = 0; i < size; i++) { subtable = &(dd->subtables[i]); empty += (double) subtable->slots * exp(-(double) subtable->keys / (double) subtable->slots); }
/* Scan the ZDD subtables. */ size = dd->sizeZ;
for (i = 0; i < size; i++) { subtable = &(dd->subtableZ[i]); empty += (double) subtable->slots * exp(-(double) subtable->keys / (double) subtable->slots); }
/* Constant table. */ subtable = &(dd->constants); empty += (double) subtable->slots * exp(-(double) subtable->keys / (double) subtable->slots);
return(1.0 - empty / (double) dd->slots);
} /* end of Cudd_ExpectedUsedSlots */
/**
@brief Returns the number of nodes in the unique table.
@details Returns the total number of nodes currently in the unique table, including the dead nodes.
@sideeffect None
@see Cudd_ReadDead
*/unsigned intCudd_ReadKeys( DdManager * dd){ return(dd->keys);
} /* end of Cudd_ReadKeys */
/**
@brief Returns the number of dead nodes in the unique table.
@sideeffect None
@see Cudd_ReadKeys
*/unsigned intCudd_ReadDead( DdManager * dd){ return(dd->dead);
} /* end of Cudd_ReadDead */
/**
@brief Reads the minDead parameter of the manager.
@details The minDead parameter is used by the package to decide whether to collect garbage or resize a subtable of the unique table when the subtable becomes too full. The application can indirectly control the value of minDead by setting the looseUpTo parameter.
@sideeffect None
@see Cudd_ReadDead Cudd_ReadLooseUpTo Cudd_SetLooseUpTo
*/unsigned intCudd_ReadMinDead( DdManager * dd){ return(dd->minDead);
} /* end of Cudd_ReadMinDead */
/**
@brief Returns the number of times reordering has occurred.
@details The number includes both the calls to Cudd_ReduceHeap from the application program and those automatically performed by the package. However, calls that do not even initiate reordering are not counted. A call may not initiate reordering if there are fewer than minsize live nodes in the manager, or if CUDD_REORDER_NONE is specified as reordering method. The calls to Cudd_ShuffleHeap are not counted.
@sideeffect None
@see Cudd_ReduceHeap Cudd_ReadReorderingTime
*/unsigned intCudd_ReadReorderings( DdManager * dd){ return(dd->reorderings);
} /* end of Cudd_ReadReorderings */
/**
@brief Returns the maximum number of times reordering may be invoked.
@sideeffect None
@see Cudd_ReadReorderings Cudd_SetMaxReorderings Cudd_ReduceHeap
*/unsigned intCudd_ReadMaxReorderings( DdManager * dd){ return(dd->maxReorderings);
} /* end of Cudd_ReadMaxReorderings */
/**
@brief Sets the maximum number of times reordering may be invoked.
@details The default value is (practically) infinite.
@sideeffect None
@see Cudd_ReadReorderings Cudd_ReadMaxReorderings Cudd_ReduceHeap
*/voidCudd_SetMaxReorderings( DdManager * dd, unsigned int mr){ dd->maxReorderings = mr;
} /* end of Cudd_SetMaxReorderings */
/**
@brief Returns the time spent in reordering.
@details Returns the number of milliseconds spent reordering variables since the manager was initialized. The time spent in collecting garbage before reordering is included.
@sideeffect None
@see Cudd_ReadReorderings
*/longCudd_ReadReorderingTime( DdManager * dd){ return(dd->reordTime);
} /* end of Cudd_ReadReorderingTime */
/**
@brief Returns the number of times garbage collection has occurred.
@details The number includes both the calls from reordering procedures and those caused by requests to create new nodes.
@sideeffect None
@see Cudd_ReadGarbageCollectionTime
*/intCudd_ReadGarbageCollections( DdManager * dd){ return(dd->garbageCollections);
} /* end of Cudd_ReadGarbageCollections */
/**
@brief Returns the time spent in garbage collection.
@details Returns the number of milliseconds spent doing garbage collection since the manager was initialized.
@sideeffect None
@see Cudd_ReadGarbageCollections
*/longCudd_ReadGarbageCollectionTime( DdManager * dd){ return(dd->GCTime);
} /* end of Cudd_ReadGarbageCollectionTime */
/**
@brief Returns the number of nodes freed.
@details Returns the number of nodes returned to the free list if the keeping of this statistic is enabled; -1 otherwise. This statistic is enabled only if the package is compiled with DD_STATS defined.
@sideeffect None
@see Cudd_ReadNodesDropped
*/doubleCudd_ReadNodesFreed( DdManager * dd){#ifdef DD_STATS
return(dd->nodesFreed);#else
(void) dd; /* avoid warning */ return(-1.0);#endif
} /* end of Cudd_ReadNodesFreed */
/**
@brief Returns the number of nodes dropped.
@details Returns the number of nodes killed by dereferencing if the keeping of this statistic is enabled; -1 otherwise. This statistic is enabled only if the package is compiled with DD_STATS defined.
@sideeffect None
@see Cudd_ReadNodesFreed
*/doubleCudd_ReadNodesDropped( DdManager * dd){#ifdef DD_STATS
return(dd->nodesDropped);#else
(void) dd; /* avoid warning */ return(-1.0);#endif
} /* end of Cudd_ReadNodesDropped */
/**
@brief Returns the number of look-ups in the unique table.
@details Returns the number of look-ups in the unique table if the keeping of this statistic is enabled; -1 otherwise. This statistic is enabled only if the package is compiled with DD_UNIQUE_PROFILE defined.
@sideeffect None
@see Cudd_ReadUniqueLinks
*/doubleCudd_ReadUniqueLookUps( DdManager * dd){#ifdef DD_UNIQUE_PROFILE
return(dd->uniqueLookUps);#else
(void) dd; /* avoid warning */ return(-1.0);#endif
} /* end of Cudd_ReadUniqueLookUps */
/**
@brief Returns the number of links followed in the unique table.
@details Returns the number of links followed during look-ups in the unique table if the keeping of this statistic is enabled; -1 otherwise. If an item is found in the first position of its collision list, the number of links followed is taken to be 0. If it is in second position, the number of links is 1, and so on. This statistic is enabled only if the package is compiled with DD_UNIQUE_PROFILE defined.
@sideeffect None
@see Cudd_ReadUniqueLookUps
*/doubleCudd_ReadUniqueLinks( DdManager * dd){#ifdef DD_UNIQUE_PROFILE
return(dd->uniqueLinks);#else
(void) dd; /* avoid warning */ return(-1.0);#endif
} /* end of Cudd_ReadUniqueLinks */
/**
@brief Reads the siftMaxVar parameter of the manager.
@details This parameter gives the maximum number of variables that will be sifted for each invocation of sifting.
@sideeffect None
@see Cudd_ReadSiftMaxSwap Cudd_SetSiftMaxVar
*/intCudd_ReadSiftMaxVar( DdManager * dd){ return(dd->siftMaxVar);
} /* end of Cudd_ReadSiftMaxVar */
/**
@brief Sets the siftMaxVar parameter of the manager.
@details This parameter gives the maximum number of variables that will be sifted for each invocation of sifting.
@sideeffect None
@see Cudd_SetSiftMaxSwap Cudd_ReadSiftMaxVar
*/voidCudd_SetSiftMaxVar( DdManager * dd, int smv){ dd->siftMaxVar = smv;
} /* end of Cudd_SetSiftMaxVar */
/**
@brief Reads the siftMaxSwap parameter of the manager.
@details This parameter gives the maximum number of swaps that will be attempted for each invocation of sifting. The real number of swaps may exceed the set limit because the package will always complete the sifting of the variable that causes the limit to be reached.
@sideeffect None
@see Cudd_ReadSiftMaxVar Cudd_SetSiftMaxSwap
*/intCudd_ReadSiftMaxSwap( DdManager * dd){ return(dd->siftMaxSwap);
} /* end of Cudd_ReadSiftMaxSwap */
/**
@brief Sets the siftMaxSwap parameter of the manager.
@details This parameter gives the maximum number of swaps that will be attempted for each invocation of sifting. The real number of swaps may exceed the set limit because the package will always complete the sifting of the variable that causes the limit to be reached.
@sideeffect None
@see Cudd_SetSiftMaxVar Cudd_ReadSiftMaxSwap
*/voidCudd_SetSiftMaxSwap( DdManager * dd, int sms){ dd->siftMaxSwap = sms;
} /* end of Cudd_SetSiftMaxSwap */
/**
@brief Reads the maxGrowth parameter of the manager.
@details This parameter determines how much the number of nodes can grow during sifting of a variable. Overall, sifting never increases the size of the decision diagrams. This parameter only refers to intermediate results. A lower value will speed up sifting, possibly at the expense of quality.
@sideeffect None
@see Cudd_SetMaxGrowth Cudd_ReadMaxGrowthAlternate
*/doubleCudd_ReadMaxGrowth( DdManager * dd){ return(dd->maxGrowth);
} /* end of Cudd_ReadMaxGrowth */
/**
@brief Sets the maxGrowth parameter of the manager.
@details This parameter determines how much the number of nodes can grow during sifting of a variable. Overall, sifting never increases the size of the decision diagrams. This parameter only refers to intermediate results. A lower value will speed up sifting, possibly at the expense of quality.
@sideeffect None
@see Cudd_ReadMaxGrowth Cudd_SetMaxGrowthAlternate
*/voidCudd_SetMaxGrowth( DdManager * dd, double mg){ dd->maxGrowth = mg;
} /* end of Cudd_SetMaxGrowth */
/**
@brief Reads the maxGrowthAlt parameter of the manager.
@details This parameter is analogous to the maxGrowth paramter, and is used every given number of reorderings instead of maxGrowth. The number of reorderings is set with Cudd_SetReorderingCycle. If the number of reorderings is 0 (default) maxGrowthAlt is never used.
@sideeffect None
@see Cudd_ReadMaxGrowth Cudd_SetMaxGrowthAlternate Cudd_SetReorderingCycle Cudd_ReadReorderingCycle
*/doubleCudd_ReadMaxGrowthAlternate( DdManager * dd){ return(dd->maxGrowthAlt);
} /* end of Cudd_ReadMaxGrowthAlternate */
/**
@brief Sets the maxGrowthAlt parameter of the manager.
@details This parameter is analogous to the maxGrowth paramter, and is used every given number of reorderings instead of maxGrowth. The number of reorderings is set with Cudd_SetReorderingCycle. If the number of reorderings is 0 (default) maxGrowthAlt is never used.
@sideeffect None
@see Cudd_ReadMaxGrowthAlternate Cudd_SetMaxGrowth Cudd_SetReorderingCycle Cudd_ReadReorderingCycle
*/voidCudd_SetMaxGrowthAlternate( DdManager * dd, double mg){ dd->maxGrowthAlt = mg;
} /* end of Cudd_SetMaxGrowthAlternate */
/**
@brief Reads the reordCycle parameter of the manager.
@details This parameter determines how often the alternate threshold on maximum growth is used in reordering.
@sideeffect None
@see Cudd_ReadMaxGrowthAlternate Cudd_SetMaxGrowthAlternate Cudd_SetReorderingCycle
*/intCudd_ReadReorderingCycle( DdManager * dd){ return(dd->reordCycle);
} /* end of Cudd_ReadReorderingCycle */
/**
@brief Sets the reordCycle parameter of the manager.
@details This parameter determines how often the alternate threshold on maximum growth is used in reordering.
@sideeffect None
@see Cudd_ReadMaxGrowthAlternate Cudd_SetMaxGrowthAlternate Cudd_ReadReorderingCycle
*/voidCudd_SetReorderingCycle( DdManager * dd, int cycle){ dd->reordCycle = cycle;
} /* end of Cudd_SetReorderingCycle */
/**
@brief Returns the variable group tree of the manager.
@sideeffect None
@see Cudd_SetTree Cudd_FreeTree Cudd_ReadZddTree
*/MtrNode *Cudd_ReadTree( DdManager * dd){ return(dd->tree);
} /* end of Cudd_ReadTree */
/**
@brief Sets the variable group tree of the manager.
@sideeffect None
@see Cudd_FreeTree Cudd_ReadTree Cudd_SetZddTree
*/voidCudd_SetTree( DdManager * dd, MtrNode * tree){ if (dd->tree != NULL) { Mtr_FreeTree(dd->tree); } dd->tree = tree; if (tree == NULL) return;
fixVarTree(tree, dd->perm, dd->size); return;
} /* end of Cudd_SetTree */
/**
@brief Frees the variable group tree of the manager.
@sideeffect None
@see Cudd_SetTree Cudd_ReadTree Cudd_FreeZddTree
*/voidCudd_FreeTree( DdManager * dd){ if (dd->tree != NULL) { Mtr_FreeTree(dd->tree); dd->tree = NULL; } return;
} /* end of Cudd_FreeTree */
/**
@brief Returns the variable group tree of the manager.
@sideeffect None
@see Cudd_SetZddTree Cudd_FreeZddTree Cudd_ReadTree
*/MtrNode *Cudd_ReadZddTree( DdManager * dd){ return(dd->treeZ);
} /* end of Cudd_ReadZddTree */
/**
@brief Sets the %ZDD variable group tree of the manager.
@sideeffect None
@see Cudd_FreeZddTree Cudd_ReadZddTree Cudd_SetTree
*/voidCudd_SetZddTree( DdManager * dd, MtrNode * tree){ if (dd->treeZ != NULL) { Mtr_FreeTree(dd->treeZ); } dd->treeZ = tree; if (tree == NULL) return;
fixVarTree(tree, dd->permZ, dd->sizeZ); return;
} /* end of Cudd_SetZddTree */
/**
@brief Frees the variable group tree of the manager.
@sideeffect None
@see Cudd_SetZddTree Cudd_ReadZddTree Cudd_FreeTree
*/voidCudd_FreeZddTree( DdManager * dd){ if (dd->treeZ != NULL) { Mtr_FreeTree(dd->treeZ); dd->treeZ = NULL; } return;
} /* end of Cudd_FreeZddTree */
/**
@brief Returns the index of the node.
@details The node pointer can be either regular or complemented.
@sideeffect None
@see Cudd_ReadIndex
*/unsigned intCudd_NodeReadIndex( DdNode const * node){ return((unsigned int) Cudd_Regular(node)->index);
} /* end of Cudd_NodeReadIndex */
/**
@brief Returns the current position of the i-th variable in the order.
@details If the index is CUDD_CONST_INDEX, returns CUDD_CONST_INDEX; otherwise, if the index is out of bounds returns -1.
@sideeffect None
@see Cudd_ReadInvPerm Cudd_ReadPermZdd
*/intCudd_ReadPerm( DdManager * dd, int i){ if (i == CUDD_CONST_INDEX) return(CUDD_CONST_INDEX); if (i < 0 || i >= dd->size) return(-1); return(dd->perm[i]);
} /* end of Cudd_ReadPerm */
/**
@brief Returns the current position of the i-th %ZDD variable in the order.
@details If the index is CUDD_CONST_INDEX, returns CUDD_CONST_INDEX; otherwise, if the index is out of bounds returns -1.
@sideeffect None
@see Cudd_ReadInvPermZdd Cudd_ReadPerm
*/intCudd_ReadPermZdd( DdManager * dd, int i){ if (i == CUDD_CONST_INDEX) return(CUDD_CONST_INDEX); if (i < 0 || i >= dd->sizeZ) return(-1); return(dd->permZ[i]);
} /* end of Cudd_ReadPermZdd */
/**
@brief Returns the index of the variable currently in the i-th position of the order.
@details If the index is CUDD_CONST_INDEX, returns CUDD_CONST_INDEX; otherwise, if the index is out of bounds returns -1.
@sideeffect None
@see Cudd_ReadPerm Cudd_ReadInvPermZdd
*/intCudd_ReadInvPerm( DdManager * dd, int i){ if (i == CUDD_CONST_INDEX) return(CUDD_CONST_INDEX); if (i < 0 || i >= dd->size) return(-1); return(dd->invperm[i]);
} /* end of Cudd_ReadInvPerm */
/**
@brief Returns the index of the %ZDD variable currently in the i-th position of the order.
@details If the index is CUDD_CONST_INDEX, returns CUDD_CONST_INDEX; otherwise, if the index is out of bounds returns -1.
@sideeffect None
@see Cudd_ReadPerm Cudd_ReadInvPermZdd
*/intCudd_ReadInvPermZdd( DdManager * dd, int i){ if (i == CUDD_CONST_INDEX) return(CUDD_CONST_INDEX); if (i < 0 || i >= dd->sizeZ) return(-1); return(dd->invpermZ[i]);
} /* end of Cudd_ReadInvPermZdd */
/**
@brief Returns the i-th element of the vars array.
@details Returns the i-th element of the vars array if it falls within the array bounds; NULL otherwise. If i is the index of an existing variable, this function produces the same result as Cudd_bddIthVar. However, if the i-th var does not exist yet, Cudd_bddIthVar will create it, whereas Cudd_ReadVars will not.
@sideeffect None
@see Cudd_bddIthVar
*/DdNode *Cudd_ReadVars( DdManager * dd, int i){ if (i < 0 || i > dd->size) return(NULL); return(dd->vars[i]);
} /* end of Cudd_ReadVars */
/**
@brief Reads the epsilon parameter of the manager.
@details The epsilon parameter control the comparison between floating point numbers.
@sideeffect None
@see Cudd_SetEpsilon
*/CUDD_VALUE_TYPECudd_ReadEpsilon( DdManager * dd){ return(dd->epsilon);
} /* end of Cudd_ReadEpsilon */
/**
@brief Sets the epsilon parameter of the manager to ep.
@details The epsilon parameter control the comparison between floating point numbers.
@sideeffect None
@see Cudd_ReadEpsilon
*/voidCudd_SetEpsilon( DdManager * dd, CUDD_VALUE_TYPE ep){ dd->epsilon = ep;
} /* end of Cudd_SetEpsilon */
/**
@brief Reads the groupcheck parameter of the manager.
@details The groupcheck parameter determines the aggregation criterion in group sifting.
@sideeffect None
@see Cudd_SetGroupcheck
*/Cudd_AggregationTypeCudd_ReadGroupcheck( DdManager * dd){ return(dd->groupcheck);
} /* end of Cudd_ReadGroupCheck */
/**
@brief Sets the parameter groupcheck of the manager to gc.
@details The groupcheck parameter determines the aggregation criterion in group sifting.
@sideeffect None
@see Cudd_ReadGroupCheck
*/voidCudd_SetGroupcheck( DdManager * dd, Cudd_AggregationType gc){ dd->groupcheck = gc;
} /* end of Cudd_SetGroupcheck */
/**
@brief Tells whether garbage collection is enabled.
@return 1 if garbage collection is enabled; 0 otherwise.
@sideeffect None
@see Cudd_EnableGarbageCollection Cudd_DisableGarbageCollection
*/intCudd_GarbageCollectionEnabled( DdManager * dd){ return(dd->gcEnabled);
} /* end of Cudd_GarbageCollectionEnabled */
/**
@brief Enables garbage collection.
@details Garbage collection is initially enabled. Therefore it is necessary to call this function only if garbage collection has been explicitly disabled.
@sideeffect None
@see Cudd_DisableGarbageCollection Cudd_GarbageCollectionEnabled
*/voidCudd_EnableGarbageCollection( DdManager * dd){ dd->gcEnabled = 1;
} /* end of Cudd_EnableGarbageCollection */
/**
@brief Disables garbage collection.
@details Garbage collection is initially enabled. This function may be called to disable it. However, garbage collection will still occur when a new node must be created and no memory is left, or when garbage collection is required for correctness. (E.g., before reordering.)
@sideeffect None
@see Cudd_EnableGarbageCollection Cudd_GarbageCollectionEnabled
*/voidCudd_DisableGarbageCollection( DdManager * dd){ dd->gcEnabled = 0;
} /* end of Cudd_DisableGarbageCollection */
/**
@brief Tells whether dead nodes are counted towards triggering reordering.
@return 1 if dead nodes are counted; 0 otherwise.
@sideeffect None
@see Cudd_TurnOnCountDead Cudd_TurnOffCountDead
*/intCudd_DeadAreCounted( DdManager * dd){ return(dd->countDead == 0 ? 1 : 0);
} /* end of Cudd_DeadAreCounted */
/**
@brief Causes the dead nodes to be counted towards triggering reordering.
@details This causes more frequent reorderings. By default dead nodes are not counted.
@sideeffect Changes the manager.
@see Cudd_TurnOffCountDead Cudd_DeadAreCounted
*/voidCudd_TurnOnCountDead( DdManager * dd){ dd->countDead = 0;
} /* end of Cudd_TurnOnCountDead */
/**
@brief Causes the dead nodes not to be counted towards triggering reordering.
@details This causes less frequent reorderings. By default dead nodes are not counted. Therefore there is no need to call this function unless Cudd_TurnOnCountDead has been previously called.
@sideeffect Changes the manager.
@see Cudd_TurnOnCountDead Cudd_DeadAreCounted
*/voidCudd_TurnOffCountDead( DdManager * dd){ dd->countDead = ~0U;
} /* end of Cudd_TurnOffCountDead */
/**
@brief Returns the current value of the recombination parameter used in group sifting.
@details A larger (positive) value makes the aggregation of variables due to the second difference criterion more likely. A smaller (negative) value makes aggregation less likely.
@sideeffect None
@see Cudd_SetRecomb
*/intCudd_ReadRecomb( DdManager * dd){ return(dd->recomb);
} /* end of Cudd_ReadRecomb */
/**
@brief Sets the value of the recombination parameter used in group sifting.
@details A larger (positive) value makes the aggregation of variables due to the second difference criterion more likely. A smaller (negative) value makes aggregation less likely. The default value is 0.
@sideeffect Changes the manager.
@see Cudd_ReadRecomb
*/voidCudd_SetRecomb( DdManager * dd, int recomb){ dd->recomb = recomb;
} /* end of Cudd_SetRecomb */
/**
@brief Returns the current value of the symmviolation parameter used in group sifting.
@details This parameter is used in group sifting to decide how many violations to the symmetry conditions <code>f10 = f01</code> or <code>f11 = f00</code> are tolerable when checking for aggregation due to extended symmetry. The value should be between 0 and 100. A small value causes fewer variables to be aggregated. The default value is 0.
@sideeffect None
@see Cudd_SetSymmviolation
*/intCudd_ReadSymmviolation( DdManager * dd){ return(dd->symmviolation);
} /* end of Cudd_ReadSymmviolation */
/**
@brief Sets the value of the symmviolation parameter used in group sifting.
@details This parameter is used in group sifting to decide how many violations to the symmetry conditions <code>f10 = f01</code> or <code>f11 = f00</code> are tolerable when checking for aggregation due to extended symmetry. The value should be between 0 and 100. A small value causes fewer variables to be aggregated. The default value is 0.
@sideeffect Changes the manager.
@see Cudd_ReadSymmviolation
*/voidCudd_SetSymmviolation( DdManager * dd, int symmviolation){ dd->symmviolation = symmviolation;
} /* end of Cudd_SetSymmviolation */
/**
@brief Returns the current value of the arcviolation parameter used in group sifting.
@details This parameter is used to decide how many arcs into <code>y</code> not coming from <code>x</code> are tolerable when checking for aggregation due to extended symmetry. The value should be between 0 and 100. A small value causes fewer variables to be aggregated. The default value is 0.
@sideeffect None
@see Cudd_SetArcviolation
*/intCudd_ReadArcviolation( DdManager * dd){ return(dd->arcviolation);
} /* end of Cudd_ReadArcviolation */
/**
@brief Sets the value of the arcviolation parameter used in group sifting.
@details This parameter is used to decide how many arcs into <code>y</code> not coming from <code>x</code> are tolerable when checking for aggregation due to extended symmetry. The value should be between 0 and 100. A small value causes fewer variables to be aggregated. The default value is 0.
@sideeffect None
@see Cudd_ReadArcviolation
*/voidCudd_SetArcviolation( DdManager * dd, int arcviolation){ dd->arcviolation = arcviolation;
} /* end of Cudd_SetArcviolation */
/**
@brief Reads the current size of the population used by the genetic algorithm for variable reordering.
@details A larger population size will cause the genetic algorithm to take more time, but will generally produce better results. The default value is 0, in which case the package uses three times the number of variables as population size, with a maximum of 120.
@sideeffect None
@see Cudd_SetPopulationSize
*/intCudd_ReadPopulationSize( DdManager * dd){ return(dd->populationSize);
} /* end of Cudd_ReadPopulationSize */
/**
@brief Sets the size of the population used by the genetic algorithm for variable reordering.
@details A larger population size will cause the genetic algorithm to take more time, but will generally produce better results. The default value is 0, in which case the package uses three times the number of variables as population size, with a maximum of 120.
@sideeffect Changes the manager.
@see Cudd_ReadPopulationSize
*/voidCudd_SetPopulationSize( DdManager * dd, int populationSize){ dd->populationSize = populationSize;
} /* end of Cudd_SetPopulationSize */
/**
@brief Reads the current number of crossovers used by the genetic algorithm for variable reordering.
@details A larger number of crossovers will cause the genetic algorithm to take more time, but will generally produce better results. The default value is 0, in which case the package uses three times the number of variables as number of crossovers, with a maximum of 60.
@sideeffect None
@see Cudd_SetNumberXovers
*/intCudd_ReadNumberXovers( DdManager * dd){ return(dd->numberXovers);
} /* end of Cudd_ReadNumberXovers */
/**
@brief Sets the number of crossovers used by the genetic algorithm for variable reordering.
@details A larger number of crossovers will cause the genetic algorithm to take more time, but will generally produce better results. The default value is 0, in which case the package uses three times the number of variables as number of crossovers, with a maximum of 60.
@sideeffect None
@see Cudd_ReadNumberXovers
*/voidCudd_SetNumberXovers( DdManager * dd, int numberXovers){ dd->numberXovers = numberXovers;
} /* end of Cudd_SetNumberXovers */
/**
@brief Returns the order randomization factor.
@details If non-zero this factor is used to determine a perturbation of the next reordering threshold. Larger factors cause larger perturbations.
@sideeffect None
@see Cudd_SetOrderRandomization
*/unsigned intCudd_ReadOrderRandomization( DdManager * dd){ return(dd->randomizeOrder);
} /* end of Cudd_ReadOrderRandomization */
/**
@brief Sets the order randomization factor.
@sideeffect None
@see Cudd_ReadOrderRandomization
*/voidCudd_SetOrderRandomization( DdManager * dd, unsigned int factor){ dd->randomizeOrder = factor;
} /* end of Cudd_SetOrderRandomization */
/**
@brief Returns the memory in use by the manager measured in bytes.
@sideeffect None
*/size_tCudd_ReadMemoryInUse( DdManager * dd){ return(dd->memused);
} /* end of Cudd_ReadMemoryInUse */
/**
@brief Prints out statistics and settings for a CUDD manager.
@return 1 if successful; 0 otherwise.
@sideeffect None
*/intCudd_PrintInfo( DdManager * dd, FILE * fp){ int retval; Cudd_ReorderingType autoMethod, autoMethodZ;
/* Modifiable parameters. */ retval = fprintf(fp,"**** CUDD modifiable parameters ****\n"); if (retval == EOF) return(0); retval = fprintf(fp,"Hard limit for cache size: %u\n", Cudd_ReadMaxCacheHard(dd)); if (retval == EOF) return(0); retval = fprintf(fp,"Cache hit threshold for resizing: %u%%\n", Cudd_ReadMinHit(dd)); if (retval == EOF) return(0); retval = fprintf(fp,"Garbage collection enabled: %s\n", Cudd_GarbageCollectionEnabled(dd) ? "yes" : "no"); if (retval == EOF) return(0); retval = fprintf(fp,"Limit for fast unique table growth: %u\n", Cudd_ReadLooseUpTo(dd)); if (retval == EOF) return(0); retval = fprintf(fp, "Maximum number of variables sifted per reordering: %d\n", Cudd_ReadSiftMaxVar(dd)); if (retval == EOF) return(0); retval = fprintf(fp, "Maximum number of variable swaps per reordering: %d\n", Cudd_ReadSiftMaxSwap(dd)); if (retval == EOF) return(0); retval = fprintf(fp,"Maximum growth while sifting a variable: %g\n", Cudd_ReadMaxGrowth(dd)); if (retval == EOF) return(0); retval = fprintf(fp,"Dynamic reordering of BDDs enabled: %s\n", Cudd_ReorderingStatus(dd,&autoMethod) ? "yes" : "no"); if (retval == EOF) return(0); retval = fprintf(fp,"Default BDD reordering method: %d\n", (int) autoMethod); if (retval == EOF) return(0); retval = fprintf(fp,"Dynamic reordering of ZDDs enabled: %s\n", Cudd_ReorderingStatusZdd(dd,&autoMethodZ) ? "yes" : "no"); if (retval == EOF) return(0); retval = fprintf(fp,"Default ZDD reordering method: %d\n", (int) autoMethodZ); if (retval == EOF) return(0); retval = fprintf(fp,"Realignment of ZDDs to BDDs enabled: %s\n", Cudd_zddRealignmentEnabled(dd) ? "yes" : "no"); if (retval == EOF) return(0); retval = fprintf(fp,"Realignment of BDDs to ZDDs enabled: %s\n", Cudd_bddRealignmentEnabled(dd) ? "yes" : "no"); if (retval == EOF) return(0); retval = fprintf(fp,"Dead nodes counted in triggering reordering: %s\n", Cudd_DeadAreCounted(dd) ? "yes" : "no"); if (retval == EOF) return(0); retval = fprintf(fp,"Group checking criterion: %u\n", (unsigned int) Cudd_ReadGroupcheck(dd)); if (retval == EOF) return(0); retval = fprintf(fp,"Recombination threshold: %d\n", Cudd_ReadRecomb(dd)); if (retval == EOF) return(0); retval = fprintf(fp,"Symmetry violation threshold: %d\n", Cudd_ReadSymmviolation(dd)); if (retval == EOF) return(0); retval = fprintf(fp,"Arc violation threshold: %d\n", Cudd_ReadArcviolation(dd)); if (retval == EOF) return(0); retval = fprintf(fp,"GA population size: %d\n", Cudd_ReadPopulationSize(dd)); if (retval == EOF) return(0); retval = fprintf(fp,"Number of crossovers for GA: %d\n", Cudd_ReadNumberXovers(dd)); if (retval == EOF) return(0); retval = fprintf(fp,"Next reordering threshold: %u\n", Cudd_ReadNextReordering(dd)); if (retval == EOF) return(0);
/* Non-modifiable parameters. */ retval = fprintf(fp,"**** CUDD non-modifiable parameters ****\n"); if (retval == EOF) return(0); retval = fprintf(fp,"Memory in use: %" PRIszt "\n", Cudd_ReadMemoryInUse(dd)); if (retval == EOF) return(0); retval = fprintf(fp,"Peak number of nodes: %ld\n", Cudd_ReadPeakNodeCount(dd)); if (retval == EOF) return(0); retval = fprintf(fp,"Peak number of live nodes: %d\n", Cudd_ReadPeakLiveNodeCount(dd)); if (retval == EOF) return(0); retval = fprintf(fp,"Number of BDD variables: %d\n", dd->size); if (retval == EOF) return(0); retval = fprintf(fp,"Number of ZDD variables: %d\n", dd->sizeZ); if (retval == EOF) return(0); retval = fprintf(fp,"Number of cache entries: %u\n", dd->cacheSlots); if (retval == EOF) return(0); retval = fprintf(fp,"Number of cache look-ups: %.0f\n", Cudd_ReadCacheLookUps(dd)); if (retval == EOF) return(0); retval = fprintf(fp,"Number of cache hits: %.0f\n", Cudd_ReadCacheHits(dd)); if (retval == EOF) return(0); retval = fprintf(fp,"Number of cache insertions: %.0f\n", dd->cacheinserts); if (retval == EOF) return(0); retval = fprintf(fp,"Number of cache collisions: %.0f\n", dd->cachecollisions); if (retval == EOF) return(0); retval = fprintf(fp,"Number of cache deletions: %.0f\n", dd->cachedeletions); if (retval == EOF) return(0); retval = cuddCacheProfile(dd,fp); if (retval == 0) return(0); retval = fprintf(fp,"Soft limit for cache size: %u\n", Cudd_ReadMaxCache(dd)); if (retval == EOF) return(0); retval = fprintf(fp,"Number of buckets in unique table: %u\n", dd->slots); if (retval == EOF) return(0); retval = fprintf(fp,"Used buckets in unique table: %.2f%% (expected %.2f%%)\n", 100.0 * Cudd_ReadUsedSlots(dd), 100.0 * Cudd_ExpectedUsedSlots(dd)); if (retval == EOF) return(0);#ifdef DD_UNIQUE_PROFILE
retval = fprintf(fp,"Unique lookups: %.0f\n", dd->uniqueLookUps); if (retval == EOF) return(0); retval = fprintf(fp,"Unique links: %.0f (%g per lookup)\n", dd->uniqueLinks, dd->uniqueLinks / dd->uniqueLookUps); if (retval == EOF) return(0);#endif
retval = fprintf(fp,"Number of BDD and ADD nodes: %u\n", dd->keys); if (retval == EOF) return(0); retval = fprintf(fp,"Number of ZDD nodes: %u\n", dd->keysZ); if (retval == EOF) return(0); retval = fprintf(fp,"Number of dead BDD and ADD nodes: %u\n", dd->dead); if (retval == EOF) return(0); retval = fprintf(fp,"Number of dead ZDD nodes: %u\n", dd->deadZ); if (retval == EOF) return(0); retval = fprintf(fp,"Total number of nodes allocated: %.0f\n", dd->allocated); if (retval == EOF) return(0); retval = fprintf(fp,"Total number of nodes reclaimed: %.0f\n", dd->reclaimed); if (retval == EOF) return(0);#ifdef DD_STATS
retval = fprintf(fp,"Nodes freed: %.0f\n", dd->nodesFreed); if (retval == EOF) return(0); retval = fprintf(fp,"Nodes dropped: %.0f\n", dd->nodesDropped); if (retval == EOF) return(0);#endif
#ifdef DD_COUNT
retval = fprintf(fp,"Number of recursive calls: %.0f\n", Cudd_ReadRecursiveCalls(dd)); if (retval == EOF) return(0);#endif
retval = fprintf(fp,"Garbage collections so far: %d\n", Cudd_ReadGarbageCollections(dd)); if (retval == EOF) return(0); retval = fprintf(fp,"Time for garbage collection: %.2f sec\n", ((double)Cudd_ReadGarbageCollectionTime(dd)/1000.0)); if (retval == EOF) return(0); retval = fprintf(fp,"Reorderings so far: %d\n", dd->reorderings); if (retval == EOF) return(0); retval = fprintf(fp,"Time for reordering: %.2f sec\n", ((double)Cudd_ReadReorderingTime(dd)/1000.0)); if (retval == EOF) return(0);#ifdef DD_COUNT
retval = fprintf(fp,"Node swaps in reordering: %.0f\n", Cudd_ReadSwapSteps(dd)); if (retval == EOF) return(0);#endif
return(1);
} /* end of Cudd_PrintInfo */
/**
@brief Reports the peak number of nodes.
@details This number includes node on the free list. At the peak, the number of nodes on the free list is guaranteed to be less than DD_MEM_CHUNK.
@sideeffect None
@see Cudd_ReadNodeCount Cudd_PrintInfo
*/longCudd_ReadPeakNodeCount( DdManager * dd){ long count = 0; DdNodePtr *scan = dd->memoryList;
while (scan != NULL) { count += DD_MEM_CHUNK; scan = (DdNodePtr *) *scan; } return(count);
} /* end of Cudd_ReadPeakNodeCount */
/**
@brief Reports the peak number of live nodes.
@sideeffect None
@see Cudd_ReadNodeCount Cudd_PrintInfo Cudd_ReadPeakNodeCount
*/intCudd_ReadPeakLiveNodeCount( DdManager * dd){ unsigned int live = dd->keys - dd->dead;
if (live > dd->peakLiveNodes) { dd->peakLiveNodes = live; } return((int)dd->peakLiveNodes);
} /* end of Cudd_ReadPeakLiveNodeCount */
/**
@brief Reports the number of nodes in BDDs and ADDs.
@details This number does not include the isolated projection functions and the unused constants. These nodes that are not counted are not part of the DDs manipulated by the application.
@sideeffect None
@see Cudd_ReadPeakNodeCount Cudd_zddReadNodeCount
*/longCudd_ReadNodeCount( DdManager * dd){ long count; int i;
#ifndef DD_NO_DEATH_ROW
cuddClearDeathRow(dd);#endif
count = (long) (dd->keys - dd->dead);
/* Count isolated projection functions. Their number is subtracted
** from the node count because they are not part of the BDDs. */ for (i=0; i < dd->size; i++) { if (dd->vars[i]->ref == 1) count--; } /* Subtract from the count the unused constants. */ if (DD_ZERO(dd)->ref == 1) count--; if (DD_PLUS_INFINITY(dd)->ref == 1) count--; if (DD_MINUS_INFINITY(dd)->ref == 1) count--;
return(count);
} /* end of Cudd_ReadNodeCount */
/**
@brief Reports the number of nodes in ZDDs.
@details This number always includes the two constants 1 and 0.
@sideeffect None
@see Cudd_ReadPeakNodeCount Cudd_ReadNodeCount
*/longCudd_zddReadNodeCount( DdManager * dd){ return((long)(dd->keysZ - dd->deadZ + 2));
} /* end of Cudd_zddReadNodeCount */
/**
@brief Adds a function to a hook.
@details A hook is a list of application-provided functions called on certain occasions by the package.
@return 1 if the function is successfully added; 2 if the function was already in the list; 0 otherwise.
@sideeffect None
@see Cudd_RemoveHook
*/intCudd_AddHook( DdManager * dd, DD_HFP f, Cudd_HookType where){ DdHook **hook, *nextHook, *newHook;
switch (where) { case CUDD_PRE_GC_HOOK: hook = &(dd->preGCHook); break; case CUDD_POST_GC_HOOK: hook = &(dd->postGCHook); break; case CUDD_PRE_REORDERING_HOOK: hook = &(dd->preReorderingHook); break; case CUDD_POST_REORDERING_HOOK: hook = &(dd->postReorderingHook); break; default: return(0); } /* Scan the list and find whether the function is already there.
** If so, just return. */ nextHook = *hook; while (nextHook != NULL) { if (nextHook->f == f) { return(2); } hook = &(nextHook->next); nextHook = nextHook->next; } /* The function was not in the list. Create a new item and append it
** to the end of the list. */ newHook = ALLOC(DdHook,1); if (newHook == NULL) { dd->errorCode = CUDD_MEMORY_OUT; return(0); } newHook->next = NULL; newHook->f = f; *hook = newHook; return(1);
} /* end of Cudd_AddHook */
/**
@brief Removes a function from a hook.
@details A hook is a list of application-provided functions called on certain occasions by the package.
@return 1 if successful; 0 the function was not in the list.
@sideeffect None
@see Cudd_AddHook
*/intCudd_RemoveHook( DdManager * dd, DD_HFP f, Cudd_HookType where){ DdHook **hook, *nextHook;
switch (where) { case CUDD_PRE_GC_HOOK: hook = &(dd->preGCHook); break; case CUDD_POST_GC_HOOK: hook = &(dd->postGCHook); break; case CUDD_PRE_REORDERING_HOOK: hook = &(dd->preReorderingHook); break; case CUDD_POST_REORDERING_HOOK: hook = &(dd->postReorderingHook); break; default: return(0); } nextHook = *hook; while (nextHook != NULL) { if (nextHook->f == f) { *hook = nextHook->next; FREE(nextHook); return(1); } hook = &(nextHook->next); nextHook = nextHook->next; }
return(0);
} /* end of Cudd_RemoveHook */
/**
@brief Checks whether a function is in a hook.
@details A hook is a list of application-provided functions called on certain occasions by the package.
@return 1 if the function is found; 0 otherwise.
@sideeffect None
@see Cudd_AddHook Cudd_RemoveHook
*/intCudd_IsInHook( DdManager * dd, DD_HFP f, Cudd_HookType where){ DdHook *hook;
switch (where) { case CUDD_PRE_GC_HOOK: hook = dd->preGCHook; break; case CUDD_POST_GC_HOOK: hook = dd->postGCHook; break; case CUDD_PRE_REORDERING_HOOK: hook = dd->preReorderingHook; break; case CUDD_POST_REORDERING_HOOK: hook = dd->postReorderingHook; break; default: return(0); } /* Scan the list and find whether the function is already there. */ while (hook != NULL) { if (hook->f == f) { return(1); } hook = hook->next; } return(0);
} /* end of Cudd_IsInHook */
/**
@brief Sample hook function to call before reordering.
@details Prints on the manager's stdout reordering method and initial size. @return 1 if successful; 0 otherwise.
@sideeffect None
@see Cudd_StdPostReordHook
*/intCudd_StdPreReordHook( DdManager *dd, const char *str, void *data){ Cudd_ReorderingType method = (Cudd_ReorderingType) (ptruint) data; int retval;
retval = fprintf(dd->out,"%s reordering with ", str); if (retval == EOF) return(0); switch (method) { case CUDD_REORDER_SIFT_CONVERGE: case CUDD_REORDER_SYMM_SIFT_CONV: case CUDD_REORDER_GROUP_SIFT_CONV: case CUDD_REORDER_WINDOW2_CONV: case CUDD_REORDER_WINDOW3_CONV: case CUDD_REORDER_WINDOW4_CONV: case CUDD_REORDER_LINEAR_CONVERGE: retval = fprintf(dd->out,"converging "); if (retval == EOF) return(0); break; default: break; } switch (method) { case CUDD_REORDER_RANDOM: case CUDD_REORDER_RANDOM_PIVOT: retval = fprintf(dd->out,"random"); break; case CUDD_REORDER_SIFT: case CUDD_REORDER_SIFT_CONVERGE: retval = fprintf(dd->out,"sifting"); break; case CUDD_REORDER_SYMM_SIFT: case CUDD_REORDER_SYMM_SIFT_CONV: retval = fprintf(dd->out,"symmetric sifting"); break; case CUDD_REORDER_LAZY_SIFT: retval = fprintf(dd->out,"lazy sifting"); break; case CUDD_REORDER_GROUP_SIFT: case CUDD_REORDER_GROUP_SIFT_CONV: retval = fprintf(dd->out,"group sifting"); break; case CUDD_REORDER_WINDOW2: case CUDD_REORDER_WINDOW3: case CUDD_REORDER_WINDOW4: case CUDD_REORDER_WINDOW2_CONV: case CUDD_REORDER_WINDOW3_CONV: case CUDD_REORDER_WINDOW4_CONV: retval = fprintf(dd->out,"window"); break; case CUDD_REORDER_ANNEALING: retval = fprintf(dd->out,"annealing"); break; case CUDD_REORDER_GENETIC: retval = fprintf(dd->out,"genetic"); break; case CUDD_REORDER_LINEAR: case CUDD_REORDER_LINEAR_CONVERGE: retval = fprintf(dd->out,"linear sifting"); break; case CUDD_REORDER_EXACT: retval = fprintf(dd->out,"exact"); break; default: return(0); } if (retval == EOF) return(0);
retval = fprintf(dd->out,": from %ld to ... ", strcmp(str, "BDD") == 0 ? Cudd_ReadNodeCount(dd) : Cudd_zddReadNodeCount(dd)); if (retval == EOF) return(0); fflush(dd->out); return(1);
} /* end of Cudd_StdPreReordHook */
/**
@brief Sample hook function to call after reordering.
@details Prints on the manager's stdout final size and reordering time. @return 1 if successful; 0 otherwise.
@sideeffect None
@see Cudd_StdPreReordHook
*/intCudd_StdPostReordHook( DdManager *dd, const char *str, void *data){ unsigned long initialTime = (unsigned long) (ptruint) data; int retval; unsigned long finalTime = util_cpu_time(); double totalTimeSec = (double)(finalTime - initialTime) / 1000.0;
retval = fprintf(dd->out,"%ld nodes in %g sec\n", strcmp(str, "BDD") == 0 ? Cudd_ReadNodeCount(dd) : Cudd_zddReadNodeCount(dd), totalTimeSec); if (retval == EOF) return(0); retval = fflush(dd->out); if (retval == EOF) return(0); return(1);
} /* end of Cudd_StdPostReordHook */
/**
@brief Enables reporting of reordering stats.
@return 1 if successful; 0 otherwise.
@sideeffect Installs functions in the pre-reordering and post-reordering hooks.
@see Cudd_DisableReorderingReporting Cudd_ReorderingReporting
*/intCudd_EnableReorderingReporting( DdManager *dd){ if (!Cudd_AddHook(dd, Cudd_StdPreReordHook, CUDD_PRE_REORDERING_HOOK)) { return(0); } if (!Cudd_AddHook(dd, Cudd_StdPostReordHook, CUDD_POST_REORDERING_HOOK)) { return(0); } return(1);
} /* end of Cudd_EnableReorderingReporting */
/**
@brief Disables reporting of reordering stats.
@return 1 if successful; 0 otherwise.
@sideeffect Removes functions from the pre-reordering and post-reordering hooks.
@see Cudd_EnableReorderingReporting Cudd_ReorderingReporting
*/intCudd_DisableReorderingReporting( DdManager *dd){ if (!Cudd_RemoveHook(dd, Cudd_StdPreReordHook, CUDD_PRE_REORDERING_HOOK)) { return(0); } if (!Cudd_RemoveHook(dd, Cudd_StdPostReordHook, CUDD_POST_REORDERING_HOOK)) { return(0); } return(1);
} /* end of Cudd_DisableReorderingReporting */
/**
@brief Returns 1 if reporting of reordering stats is enabled; 0 otherwise.
@sideeffect none
@see Cudd_EnableReorderingReporting Cudd_DisableReorderingReporting
*/intCudd_ReorderingReporting( DdManager *dd){ return(Cudd_IsInHook(dd, Cudd_StdPreReordHook, CUDD_PRE_REORDERING_HOOK));
} /* end of Cudd_ReorderingReporting */
/**
@brief Hook function to print the current variable order.
@details It may be called before or after reordering. Prints on the manager's stdout a parenthesized list that describes the variable groups.
@return 1 if successful; 0 otherwise.
@sideeffect None
@see Cudd_StdPreReordHook
*/intCudd_PrintGroupedOrder( DdManager * dd, const char *str, void *data){ (void) data; /* avoid warning */ int isBdd = strcmp(str, "ZDD"); MtrNode *tree = isBdd ? dd->tree : dd->treeZ; int *invperm = isBdd ? dd->invperm : dd->invpermZ; int size = isBdd ? dd->size : dd->sizeZ; if (tree == NULL) { int i, retval; for (i=0; i < size; i++) { retval = fprintf(dd->out, "%c%d", i==0 ? '(' : ',', invperm[i]); if (retval == EOF) return(0); } retval = fprintf(dd->out,")\n"); return (retval != EOF); } else { return Mtr_PrintGroupedOrder(tree,invperm,dd->out); } } /* end of Cudd_PrintGroupedOrder */
/**
@brief Enables monitoring of ordering.
@return 1 if successful; 0 otherwise.
@sideeffect Installs functions in the pre-reordering and post-reordering hooks.
@see Cudd_EnableReorderingReporting
*/intCudd_EnableOrderingMonitoring( DdManager *dd){ if (!Cudd_AddHook(dd, Cudd_PrintGroupedOrder, CUDD_PRE_REORDERING_HOOK)) { return(0); } if (!Cudd_AddHook(dd, Cudd_StdPreReordHook, CUDD_PRE_REORDERING_HOOK)) { return(0); } if (!Cudd_AddHook(dd, Cudd_StdPostReordHook, CUDD_POST_REORDERING_HOOK)) { return(0); } if (!Cudd_AddHook(dd, Cudd_PrintGroupedOrder, CUDD_POST_REORDERING_HOOK)) { return(0); } return(1);
} /* end of Cudd_EnableOrderingMonitoring */
/**
@brief Disables monitoring of ordering.
@return 1 if successful; 0 otherwise.
@sideeffect Removes functions from the pre-reordering and post-reordering hooks.
@see Cudd_EnableOrderingMonitoring
*/intCudd_DisableOrderingMonitoring( DdManager *dd){ if (!Cudd_RemoveHook(dd, Cudd_StdPreReordHook, CUDD_PRE_REORDERING_HOOK)) { return(0); } if (!Cudd_RemoveHook(dd, Cudd_PrintGroupedOrder, CUDD_PRE_REORDERING_HOOK)) { return(0); } if (!Cudd_RemoveHook(dd, Cudd_PrintGroupedOrder, CUDD_POST_REORDERING_HOOK)) { return(0); } if (!Cudd_RemoveHook(dd, Cudd_StdPostReordHook, CUDD_POST_REORDERING_HOOK)) { return(0); } return(1);
} /* end of Cudd_DisableOrderingMonitoring */
/**
@brief Returns 1 if monitoring of ordering is enabled; 0 otherwise.
@sideeffect none
@see Cudd_EnableOrderingMonitoring Cudd_DisableOrderingMonitoring
*/intCudd_OrderingMonitoring( DdManager *dd){ return(Cudd_IsInHook(dd, Cudd_PrintGroupedOrder, CUDD_PRE_REORDERING_HOOK));
} /* end of Cudd_OrderingMonitoring */
/**
@brief Sets the application hook.
@sideeffect None
@see Cudd_ReadApplicationHook
*/voidCudd_SetApplicationHook( DdManager *dd, void * value){ dd->hooks = value;
} /* end of Cudd_SetApplicationHook */
/**
@brief Reads the application hook.
@sideeffect None
@see Cudd_SetApplicationHook
*/void *Cudd_ReadApplicationHook( DdManager *dd){ return(dd->hooks);
} /* end of Cudd_ReadApplicationHook */
/**
@brief Returns the code of the last error.
@details The error codes are defined in cudd.h.
@sideeffect None
@see Cudd_ClearErrorCode
*/Cudd_ErrorTypeCudd_ReadErrorCode( DdManager *dd){ return(dd->errorCode);
} /* end of Cudd_ReadErrorCode */
/**
@brief Clear the error code of a manager.
@sideeffect None
@see Cudd_ReadErrorCode
*/voidCudd_ClearErrorCode( DdManager *dd){ dd->errorCode = CUDD_NO_ERROR;
} /* end of Cudd_ClearErrorCode */
/**
@brief Installs a handler for failed memory allocations.
@details Changing the handler only has an effect if the wrappers in safe_mem.c are in use.
@return the current handler.*/DD_OOMFPCudd_InstallOutOfMemoryHandler( DD_OOMFP newHandler){ DD_OOMFP oldHandler = MMoutOfMemory; MMoutOfMemory = newHandler; return oldHandler;
} /* end of Cudd_InstallOutOfMemoryHandler */
/**
@brief Reads the stdout of a manager.
@details This is the file pointer to which messages normally going to stdout are written. It is initialized to stdout. Cudd_SetStdout allows the application to redirect it.
@sideeffect None
@see Cudd_SetStdout Cudd_ReadStderr
*/FILE *Cudd_ReadStdout( DdManager *dd){ return(dd->out);
} /* end of Cudd_ReadStdout */
/**
@brief Sets the stdout of a manager.
@sideeffect None
@see Cudd_ReadStdout Cudd_SetStderr
*/voidCudd_SetStdout( DdManager *dd, FILE *fp){ dd->out = fp;
} /* end of Cudd_SetStdout */
/**
@brief Reads the stderr of a manager.
@details This is the file pointer to which messages normally going to stderr are written. It is initialized to stderr. Cudd_SetStderr allows the application to redirect it.
@sideeffect None
@see Cudd_SetStderr Cudd_ReadStdout
*/FILE *Cudd_ReadStderr( DdManager *dd){ return(dd->err);
} /* end of Cudd_ReadStderr */
/**
@brief Sets the stderr of a manager.
@sideeffect None
@see Cudd_ReadStderr Cudd_SetStdout
*/voidCudd_SetStderr( DdManager *dd, FILE *fp){ dd->err = fp;
} /* end of Cudd_SetStderr */
/**
@brief Returns the threshold for the next dynamic reordering.
@details The threshold is in terms of number of nodes and is in effect only if reordering is enabled. The count does not include the dead nodes, unless the countDead parameter of the manager has been changed from its default setting.
@sideeffect None
@see Cudd_SetNextReordering
*/unsigned intCudd_ReadNextReordering( DdManager *dd){ return(dd->nextDyn);
} /* end of Cudd_ReadNextReordering */
/**
@brief Sets the threshold for the next dynamic reordering.
@details The threshold is in terms of number of nodes and is in effect only if reordering is enabled. The count does not include the dead nodes, unless the countDead parameter of the manager has been changed from its default setting.
@sideeffect None
@see Cudd_ReadNextReordering
*/voidCudd_SetNextReordering( DdManager *dd, unsigned int next){ dd->nextDyn = next;
} /* end of Cudd_SetNextReordering */
/**
@brief Reads the number of elementary reordering steps.
@sideeffect none
*/doubleCudd_ReadSwapSteps( DdManager *dd){#ifdef DD_COUNT
return(dd->swapSteps);#else
(void) dd; /* avoid warning */ return(-1);#endif
} /* end of Cudd_ReadSwapSteps */
/**
@brief Reads the maximum allowed number of live nodes.
@details When this number is exceeded, the package returns NULL.
@sideeffect none
@see Cudd_SetMaxLive
*/unsigned intCudd_ReadMaxLive( DdManager *dd){ return(dd->maxLive);
} /* end of Cudd_ReadMaxLive */
/**
@brief Sets the maximum allowed number of live nodes.
@details When this number is exceeded, the package returns NULL.
@sideeffect none
@see Cudd_ReadMaxLive
*/voidCudd_SetMaxLive( DdManager *dd, unsigned int maxLive){ dd->maxLive = maxLive;
} /* end of Cudd_SetMaxLive */
/**
@brief Reads the maximum allowed memory.
@details When this number is exceeded, the package returns NULL.
@sideeffect none
@see Cudd_SetMaxMemory
*/size_tCudd_ReadMaxMemory( DdManager *dd){ return(dd->maxmemhard);
} /* end of Cudd_ReadMaxMemory */
/**
@brief Sets the maximum allowed memory.
@details When this number is exceeded, the package returns NULL.
@return the previous limit.
@sideeffect none
@see Cudd_ReadMaxMemory
*/size_tCudd_SetMaxMemory( DdManager *dd, size_t maxMemory){ size_t oldLimit = dd->maxmemhard; dd->maxmemhard = maxMemory; return oldLimit;
} /* end of Cudd_SetMaxMemory */
/**
@brief Prevents sifting of a variable.
@details This function sets a flag to prevent sifting of a variable.
@return 1 if successful; 0 otherwise (i.e., invalid variable index).
@sideeffect Changes the "bindVar" flag in DdSubtable.
@see Cudd_bddUnbindVar
*/intCudd_bddBindVar( DdManager *dd /**< manager */, int index /**< variable index */){ if (index >= dd->size || index < 0) return(0); dd->subtables[dd->perm[index]].bindVar = 1; return(1);
} /* end of Cudd_bddBindVar */
/**
@brief Allows the sifting of a variable.
@details This function resets the flag that prevents the sifting of a variable. In successive variable reorderings, the variable will NOT be skipped, that is, sifted. Initially all variables can be sifted. It is necessary to call this function only to re-enable sifting after a call to Cudd_bddBindVar.
@return 1 if successful; 0 otherwise (i.e., invalid variable index).
@sideeffect Changes the "bindVar" flag in DdSubtable.
@see Cudd_bddBindVar
*/intCudd_bddUnbindVar( DdManager *dd /**< manager */, int index /**< variable index */){ if (index >= dd->size || index < 0) return(0); dd->subtables[dd->perm[index]].bindVar = 0; return(1);
} /* end of Cudd_bddUnbindVar */
/**
@brief Tells whether a variable can be sifted.
@details This function returns 1 if a variable is enabled for sifting. Initially all variables can be sifted. This function returns 0 if there has been a previous call to Cudd_bddBindVar for that variable not followed by a call to Cudd_bddUnbindVar. The function returns 0 also in the case in which the index of the variable is out of bounds.
@sideeffect none
@see Cudd_bddBindVar Cudd_bddUnbindVar
*/intCudd_bddVarIsBound( DdManager *dd /**< manager */, int index /**< variable index */){ if (index >= dd->size || index < 0) return(0); return(dd->subtables[dd->perm[index]].bindVar);
} /* end of Cudd_bddVarIsBound */
/**
@brief Sets a variable type to primary input.
@details The variable type is used by lazy sifting.
@return 1 if successful; 0 otherwise.
@sideeffect modifies the manager
@see Cudd_bddSetPsVar Cudd_bddSetNsVar Cudd_bddIsPiVar
*/intCudd_bddSetPiVar( DdManager *dd /**< manager */, int index /**< variable index */){ if (index >= dd->size || index < 0) return (0); dd->subtables[dd->perm[index]].varType = CUDD_VAR_PRIMARY_INPUT; return(1);
} /* end of Cudd_bddSetPiVar */
/**
@brief Sets a variable type to present state.
@details The variable type is used by lazy sifting.
@return 1 if successful; 0 otherwise.
@sideeffect modifies the manager
@see Cudd_bddSetPiVar Cudd_bddSetNsVar Cudd_bddIsPsVar
*/intCudd_bddSetPsVar( DdManager *dd /**< manager */, int index /**< variable index */){ if (index >= dd->size || index < 0) return (0); dd->subtables[dd->perm[index]].varType = CUDD_VAR_PRESENT_STATE; return(1);
} /* end of Cudd_bddSetPsVar */
/**
@brief Sets a variable type to next state.
@details The variable type is used by lazy sifting.
@return 1 if successful; 0 otherwise.
@sideeffect modifies the manager
@see Cudd_bddSetPiVar Cudd_bddSetPsVar Cudd_bddIsNsVar
*/intCudd_bddSetNsVar( DdManager *dd /**< manager */, int index /**< variable index */){ if (index >= dd->size || index < 0) return (0); dd->subtables[dd->perm[index]].varType = CUDD_VAR_NEXT_STATE; return(1);
} /* end of Cudd_bddSetNsVar */
/**
@brief Checks whether a variable is primary input.
@return 1 if the variable's type is primary input; 0 if the variable exists but is not a primary input; -1 if the variable does not exist.
@sideeffect none
@see Cudd_bddSetPiVar Cudd_bddIsPsVar Cudd_bddIsNsVar
*/intCudd_bddIsPiVar( DdManager *dd /**< manager */, int index /**< variable index */){ if (index >= dd->size || index < 0) return -1; return (dd->subtables[dd->perm[index]].varType == CUDD_VAR_PRIMARY_INPUT);
} /* end of Cudd_bddIsPiVar */
/**
@brief Checks whether a variable is present state.
@return 1 if the variable's type is present state; 0 if the variable exists but is not a present state; -1 if the variable does not exist.
@sideeffect none
@see Cudd_bddSetPsVar Cudd_bddIsPiVar Cudd_bddIsNsVar
*/intCudd_bddIsPsVar( DdManager *dd, int index){ if (index >= dd->size || index < 0) return -1; return (dd->subtables[dd->perm[index]].varType == CUDD_VAR_PRESENT_STATE);
} /* end of Cudd_bddIsPsVar */
/**
@brief Checks whether a variable is next state.
@return 1 if the variable's type is present state; 0 if the variable exists but is not a present state; -1 if the variable does not exist.
@sideeffect none
@see Cudd_bddSetNsVar Cudd_bddIsPiVar Cudd_bddIsPsVar
*/intCudd_bddIsNsVar( DdManager *dd, int index){ if (index >= dd->size || index < 0) return -1; return (dd->subtables[dd->perm[index]].varType == CUDD_VAR_NEXT_STATE);
} /* end of Cudd_bddIsNsVar */
/**
@brief Sets a corresponding pair index for a given index.
@details These pair indices are present and next state variable.
@return 1 if successful; 0 otherwise.
@sideeffect modifies the manager
@see Cudd_bddReadPairIndex
*/intCudd_bddSetPairIndex( DdManager *dd /**< manager */, int index /**< variable index */, int pairIndex /**< corresponding variable index */){ if (index >= dd->size || index < 0) return(0); dd->subtables[dd->perm[index]].pairIndex = pairIndex; return(1);
} /* end of Cudd_bddSetPairIndex */
/**
@brief Reads a corresponding pair index for a given index.
@details These pair indices are present and next state variable.
@return the corresponding variable index if the variable exists; -1 otherwise.
@sideeffect modifies the manager
@see Cudd_bddSetPairIndex
*/intCudd_bddReadPairIndex( DdManager *dd, int index){ if (index >= dd->size || index < 0) return -1; return dd->subtables[dd->perm[index]].pairIndex;
} /* end of Cudd_bddReadPairIndex */
/**
@brief Sets a variable to be grouped.
@details This function is used for lazy sifting.
@return 1 if successful; 0 otherwise.
@sideeffect modifies the manager
@see Cudd_bddSetVarHardGroup Cudd_bddResetVarToBeGrouped
*/intCudd_bddSetVarToBeGrouped( DdManager *dd, int index){ if (index >= dd->size || index < 0) return(0); if (dd->subtables[dd->perm[index]].varToBeGrouped <= CUDD_LAZY_SOFT_GROUP) { dd->subtables[dd->perm[index]].varToBeGrouped = CUDD_LAZY_SOFT_GROUP; } return(1);
} /* end of Cudd_bddSetVarToBeGrouped */
/**
@brief Sets a variable to be a hard group.
@details This function is used for lazy sifting.
@return 1 if successful; 0 otherwise.
@sideeffect modifies the manager
@see Cudd_bddSetVarToBeGrouped Cudd_bddResetVarToBeGrouped Cudd_bddIsVarHardGroup
*/intCudd_bddSetVarHardGroup( DdManager *dd, int index){ if (index >= dd->size || index < 0) return(0); dd->subtables[dd->perm[index]].varToBeGrouped = CUDD_LAZY_HARD_GROUP; return(1);
} /* end of Cudd_bddSetVarHardGrouped */
/**
@brief Resets a variable not to be grouped.
@details This function is used for lazy sifting.
@return 1 if successful; 0 otherwise.
@sideeffect modifies the manager
@see Cudd_bddSetVarToBeGrouped Cudd_bddSetVarHardGroup
*/intCudd_bddResetVarToBeGrouped( DdManager *dd, int index){ if (index >= dd->size || index < 0) return(0); if (dd->subtables[dd->perm[index]].varToBeGrouped <= CUDD_LAZY_SOFT_GROUP) { dd->subtables[dd->perm[index]].varToBeGrouped = CUDD_LAZY_NONE; } return(1);
} /* end of Cudd_bddResetVarToBeGrouped */
/**
@brief Checks whether a variable is set to be grouped.
@details This function is used for lazy sifting.
@sideeffect none
*/intCudd_bddIsVarToBeGrouped( DdManager *dd, int index){ if (index >= dd->size || index < 0) return(-1); if (dd->subtables[dd->perm[index]].varToBeGrouped == CUDD_LAZY_UNGROUP) return(0); else return(dd->subtables[dd->perm[index]].varToBeGrouped);
} /* end of Cudd_bddIsVarToBeGrouped */
/**
@brief Sets a variable to be ungrouped.
@details This function is used for lazy sifting.
@return 1 if successful; 0 otherwise.
@sideeffect modifies the manager
@see Cudd_bddIsVarToBeUngrouped
*/intCudd_bddSetVarToBeUngrouped( DdManager *dd, int index){ if (index >= dd->size || index < 0) return(0); dd->subtables[dd->perm[index]].varToBeGrouped = CUDD_LAZY_UNGROUP; return(1);
} /* end of Cudd_bddSetVarToBeGrouped */
/**
@brief Checks whether a variable is set to be ungrouped.
@details This function is used for lazy sifting.
@return 1 if the variable is marked to be ungrouped; 0 if the variable exists, but it is not marked to be ungrouped; -1 if the variable does not exist.
@sideeffect none
@see Cudd_bddSetVarToBeUngrouped
*/intCudd_bddIsVarToBeUngrouped( DdManager *dd, int index){ if (index >= dd->size || index < 0) return(-1); return dd->subtables[dd->perm[index]].varToBeGrouped == CUDD_LAZY_UNGROUP;
} /* end of Cudd_bddIsVarToBeGrouped */
/**
@brief Checks whether a variable is set to be in a hard group.
@details This function is used for lazy sifting.
@return 1 if the variable is marked to be in a hard group; 0 if the variable exists, but it is not marked to be in a hard group; -1 if the variable does not exist.
@sideeffect none
@see Cudd_bddSetVarHardGroup
*/intCudd_bddIsVarHardGroup( DdManager *dd, int index){ if (index >= dd->size || index < 0) return(-1); if (dd->subtables[dd->perm[index]].varToBeGrouped == CUDD_LAZY_HARD_GROUP) return(1); return(0);
} /* end of Cudd_bddIsVarToBeGrouped */
/*---------------------------------------------------------------------------*//* Definition of internal functions *//*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*//* Definition of static functions *//*---------------------------------------------------------------------------*/
/**
@brief Fixes a variable group tree.
@sideeffect Changes the variable group tree.
*/static voidfixVarTree( MtrNode * treenode, int * perm, int size){ treenode->index = treenode->low; treenode->low = ((int) treenode->index < size) ? (MtrHalfWord) perm[treenode->index] : treenode->index; if (treenode->child != NULL) fixVarTree(treenode->child, perm, size); if (treenode->younger != NULL) fixVarTree(treenode->younger, perm, size); return;
} /* end of fixVarTree */
/**
@brief Adds multiplicity groups to a %ZDD variable group tree.
@details This function creates the groups for set of %ZDD variables (whose cardinality is given by parameter multiplicity) that are created for each %BDD variable in Cudd_zddVarsFromBddVars. The crux of the matter is to determine the index each new group. (The index of the first variable in the group.) We first build all the groups for the children of a node, and then deal with the %ZDD variables that are directly attached to the node. The problem for these is that the tree itself does not provide information on their position inside the group. While we deal with the children of the node, therefore, we keep track of all the positions they occupy. The remaining positions in the tree can be freely used. Also, we keep track of all the variables placed in the children. All the remaining variables are directly attached to the group. We can then place any pair of variables not yet grouped in any pair of available positions in the node.
@return 1 if successful; 0 otherwise.
@sideeffect Changes the variable group tree.
@see Cudd_zddVarsFromBddVars
*/static intaddMultiplicityGroups( DdManager *dd /**< manager */, MtrNode *treenode /**< current tree node */, int multiplicity /**< how many %ZDD vars per %BDD var */, char *vmask /**< variable pairs for which a group has been already built */, char *lmask /**< levels for which a group has already been built*/){ int startV, stopV, startL; int i, j; MtrNode *auxnode = treenode;
while (auxnode != NULL) { if (auxnode->child != NULL) { addMultiplicityGroups(dd,auxnode->child,multiplicity,vmask,lmask); } /* Build remaining groups. */ startV = dd->permZ[auxnode->index] / multiplicity; startL = auxnode->low / multiplicity; stopV = startV + auxnode->size / multiplicity; /* Walk down vmask starting at startV and build missing groups. */ for (i = startV, j = startL; i < stopV; i++) { if (vmask[i] == 0) { MtrNode *node; while (lmask[j] == 1) j++; node = Mtr_MakeGroup(auxnode, j * multiplicity, multiplicity, MTR_FIXED); if (node == NULL) { return(0); } node->index = dd->invpermZ[i * multiplicity]; vmask[i] = 1; lmask[j] = 1; } } auxnode = auxnode->younger; } return(1);
} /* end of addMultiplicityGroups */
|
