/**
* @brief Basic ADD test.
* @return 0 if successful; -1 otherwise.
*/
static int
testAdd(int verbosity)
{
DdManager *manager;
DdNode *f, *var, *tmp, *bg;
int i, ret;
CUDD_VALUE_TYPE pinf;
manager = Cudd_Init(0, 0, CUDD_UNIQUE_SLOTS, CUDD_CACHE_SLOTS, 0);
if (!manager) {
if (verbosity) {
printf("initialization failed\n");
}
return -1;
}
pinf = Cudd_V(Cudd_ReadPlusInfinity(manager));
if (verbosity) {
printf("Plus infinity is %g\n", pinf);
}
f = Cudd_addConst(manager,5);
Cudd_Ref(f);
for (i = 3; i >= 0; i--) {
var = Cudd_addIthVar(manager,i);
Cudd_Ref(var);
tmp = Cudd_addApply(manager,Cudd_addTimes,var,f);
Cudd_Ref(tmp);
Cudd_RecursiveDeref(manager,f);
Cudd_RecursiveDeref(manager,var);
f = tmp;
}
if (verbosity) {
Cudd_PrintMinterm(manager, f);
printf("\n");
}
Cudd_RecursiveDeref(manager, f);
bg = Cudd_ReadBackground(manager);
if (verbosity) {
printf("background (%g) minterms : ", Cudd_V(bg));
Cudd_ApaPrintMinterm(Cudd_ReadStdout(manager), manager, bg, 0);
}
ret = Cudd_CheckZeroRef(manager);
if (ret != 0 && verbosity) {
printf("%d non-zero ADD reference counts after dereferencing\n", ret);
}
Cudd_Quit(manager);
return ret != 0;
}
/**Function********************************************************************
Synopsis [Bellman-Ford algorithm for single-source shortest paths.]
Description [Bellman-Ford algorithm for single-source shortest
paths. Returns the vector of the distances of all states from the
initial states. In case of multiple initial states the distance for
each state is from the nearest initial state. Negative-weight
cycles are detected, though only in the naive way. (Lack of
convergence after nodes-1 iterations.) In such a case, a constant
ADD with value minus infinity is returned. Bellman-Ford is based on
matrix-vector multiplication. The matrix is the distance matrix
D(x,y), such that D(a,b) is the length of the arc connecting state a
to state b. The vector V(x) stores the distances of all states from
the initial states. The actual vector used in the matrix-vector
multiplication is diff(x), that holds those distances that have
changed during the last update.]
SideEffects []
SeeAlso [ntrWarshall ntrSquare]
******************************************************************************/
static DdNode *
ntrBellman(
DdManager *dd,
DdNode *D,
DdNode *source,
DdNode **x,
DdNode **y,
int vars,
int pr)
{
DdNode *u, *w, *V, *min, *diff;
DdApaNumber i, nodes, one;
int digits = vars + 1;
/* To avoid overflow when there are many variables, use APA. */
nodes = Cudd_NewApaNumber(digits);
Cudd_ApaPowerOfTwo(digits,nodes,vars);
i = Cudd_NewApaNumber(digits);
one = Cudd_NewApaNumber(digits);
Cudd_ApaSetToLiteral(digits,one,1);
#if 0
/* Find the distances from the initial state along paths using one
** arc. */
w = Cudd_Cofactor(dd,D,source); /* works only if source is a cube */
Cudd_Ref(w);
V = Cudd_addSwapVariables(dd,w,x,y,vars);
Cudd_Ref(V);
Cudd_RecursiveDeref(dd,w);
#endif
/* The initial states are at distance 0. The other states are
** initially at infinite distance. */
V = Cudd_addIte(dd,source,Cudd_ReadZero(dd),Cudd_ReadPlusInfinity(dd));
Cudd_Ref(V);
/* Selective trace algorithm. For the next update, only consider the
** nodes whose distance has changed in the last update. */
diff = V;
Cudd_Ref(diff);
for (Cudd_ApaSetToLiteral(digits,i,1);
Cudd_ApaCompare(digits,i,digits,nodes) < 0;
Cudd_ApaAdd(digits,i,one,i)) {
if (pr>2) {(void) printf("V"); Cudd_PrintDebug(dd,V,vars,pr);}
/* Compute the distances via triangulation as a function of x. */
w = Cudd_addTriangle(dd,diff,D,x,vars);
Cudd_Ref(w);
Cudd_RecursiveDeref(dd,diff);
u = Cudd_addSwapVariables(dd,w,x,y,vars);
Cudd_Ref(u);
Cudd_RecursiveDeref(dd,w);
if (pr>2) {(void) printf("u"); Cudd_PrintDebug(dd,u,vars,pr);}
/* Take the minimum of the previous distances and those just
** computed. */
min = Cudd_addApply(dd,Cudd_addMinimum,V,u);
Cudd_Ref(min);
Cudd_RecursiveDeref(dd,u);
if (pr>2) {(void) printf("min"); Cudd_PrintDebug(dd,min,vars,pr);}
if (V == min) { /* convergence */
Cudd_RecursiveDeref(dd,min);
if (pr>0) {
(void) printf("Terminating after ");
Cudd_ApaPrintDecimal(stdout,digits,i);
(void) printf(" iterations\n");
}
break;
}
/* Find the distances that decreased. */
diff = Cudd_addApply(dd,Cudd_addDiff,V,min);
Cudd_Ref(diff);
if (pr>2) {(void) printf("diff"); Cudd_PrintDebug(dd,diff,vars,pr);}
Cudd_RecursiveDeref(dd,V);
V = min;
}
/* Negative cycle detection. */
if (Cudd_ApaCompare(digits,i,digits,nodes) == 0 &&
diff != Cudd_ReadPlusInfinity(dd)) {
(void) printf("Negative cycle\n");
Cudd_RecursiveDeref(dd,diff);
Cudd_RecursiveDeref(dd,V);
V = Cudd_ReadMinusInfinity(dd);
Cudd_Ref(V);
}
Cudd_Deref(V);
FREE(i);
FREE(nodes);
FREE(one);
return(V);
} /* end of ntrBellman */
/**Function********************************************************************
Synopsis [Computes shortest paths in a state graph.]
Description [Computes shortest paths in the state transition graph of
a network. Three methods are availabe:
<ul>
<li> Bellman-Ford algorithm for single-source shortest paths; the
algorithm computes the distance (number of transitions) from the initial
states to all states.
<li> Floyd-Warshall algorithm for all-pair shortest paths.
<li> Repeated squaring algorithm for all-pair shortest paths.
</ul>
The function returns 1 in case of success; 0 otherwise.
]
SideEffects [ADD variables are created in the manager.]
SeeAlso []
******************************************************************************/
int
Ntr_ShortestPaths(
DdManager * dd,
BnetNetwork * net,
NtrOptions * option)
{
NtrPartTR *TR;
DdNode *edges, *source, *res, *r, *q, *bddSource;
DdNode **xadd, **yadd, **zadd;
int i;
int pr = option->verb;
int algorithm = option->shortPath;
int selectiveTrace = option->selectiveTrace;
int nvars = net->nlatches;
/* Set background to infinity for shortest paths. */
Cudd_SetBackground(dd,Cudd_ReadPlusInfinity(dd));
/* Build the monolithic TR. */
TR = Ntr_buildTR(dd,net,option,NTR_IMAGE_MONO);
/* Build the ADD variable vectors for x and y. */
xadd = ALLOC(DdNode *, nvars);
yadd = ALLOC(DdNode *, nvars);
for(i = 0; i < nvars; i++) {
q = Cudd_addIthVar(dd,TR->x[i]->index);
Cudd_Ref(q);
xadd[i] = q;
q = Cudd_addIthVar(dd,TR->y[i]->index);
Cudd_Ref(q);
yadd[i] = q;
}
/* Convert the transition relation BDD into an ADD... */
q = Cudd_BddToAdd(dd,TR->part[0]);
Cudd_Ref(q);
/* ...replacing zeroes with infinities... */
r = Cudd_addIte(dd,q,Cudd_ReadOne(dd),Cudd_ReadPlusInfinity(dd));
Cudd_Ref(r);
Cudd_RecursiveDeref(dd,q);
/* ...and zeroing the diagonal. */
q = Cudd_addXeqy(dd,nvars,xadd,yadd);
Cudd_Ref(q);
edges = Cudd_addIte(dd,q,Cudd_ReadZero(dd),r);
Cudd_Ref(edges);
Cudd_RecursiveDeref(dd,r);
Cudd_RecursiveDeref(dd,q);
switch(algorithm) {
case NTR_SHORT_BELLMAN:
bddSource = Ntr_initState(dd,net,option);
source = Cudd_BddToAdd(dd,bddSource);
Cudd_Ref(source);
res = ntrBellman(dd,edges,source,xadd,yadd,nvars,pr);
if (res == NULL) return(0);
Cudd_Ref(res);
Cudd_RecursiveDeref(dd,source);
Cudd_RecursiveDeref(dd,bddSource);
if (pr >= 0) {
(void) fprintf(stdout,"Distance Matrix");
Cudd_PrintDebug(dd,res,nvars,pr);
}
break;
case NTR_SHORT_FLOYD:
res = ntrWarshall(dd,edges,xadd,yadd,nvars,pr);
if (res == NULL) return(0);
Cudd_Ref(res);
if (pr >= 0) {
(void) fprintf(stdout,"Distance Matrix");
Cudd_PrintDebug(dd,res,2*nvars,pr);
}
break;
case NTR_SHORT_SQUARE:
/* Create a third set of ADD variables. */
zadd = ALLOC(DdNode *, nvars);
for(i = 0; i < nvars; i++) {
int level;
level = Cudd_ReadIndex(dd,TR->x[i]->index);
q = Cudd_addNewVarAtLevel(dd,level);
Cudd_Ref(q);
zadd[i] = q;
}
/* Compute the shortest paths. */
res = ntrSquare(dd,edges,zadd,yadd,xadd,nvars,pr,selectiveTrace);
if (res == NULL) return(0);
Cudd_Ref(res);
/* Dispose of the extra variables. */
for(i = 0; i < nvars; i++) {
Cudd_RecursiveDeref(dd,zadd[i]);
}
FREE(zadd);
if (pr >= 0) {
(void) fprintf(stdout,"Distance Matrix");
Cudd_PrintDebug(dd,res,2*nvars,pr);
}
break;
default:
(void) printf("Unrecognized method. Try again.\n");
return(0);
}
/* Here we should compute the paths. */
/* Clean up. */
Ntr_freeTR(dd,TR);
Cudd_RecursiveDeref(dd,edges);
Cudd_RecursiveDeref(dd,res);
for(i = 0; i < nvars; i++) {
Cudd_RecursiveDeref(dd,xadd[i]);
Cudd_RecursiveDeref(dd,yadd[i]);
}
FREE(xadd);
FREE(yadd);
if (option->autoDyn & 1) {
(void) printf("Order after short path computation\n");
if (!Bnet_PrintOrder(net,dd)) return(0);
}
return(1);
} /* end of Ntr_ShortestPaths */
