source: vis_dev/glu-2.3/src/cuBdd/doc/cuddExtDet.html @ 84

Last change on this file since 84 was 13, checked in by cecile, 13 years ago

library glu 2.3
File size: 283.2 KB
Line 
1<html>
2<head><title>The cudd package</title></head>
3<body>
4
5<h1>The cudd package</h1>
6<h2>The University of Colorado decision diagram package.</h2>
7<h3></h3>
8<hr>
9<ul>
10<li><a href="cuddExtAbs.html"><h3>External abstracts</h3></a>
11<li><a href="cuddAllAbs.html"><h3>All abstracts</h3></a>
12<li><a href="cuddExtDet.html#prototypes"><h3>External functions</h3></a>
13<li><a href="cuddAllDet.html#prototypes"><h3>All functions</h3></a>
14</ul>
15
16<hr>
17
18<a name="description">
19External functions and data strucures of the CUDD package.
20  <ul>
21  <li> To turn on the gathering of statistics, define DD_STATS.
22  <li> To link with mis, define DD_MIS.
23  </ul>
24  Modified by Abelardo Pardo to interface it to VIS.
25</a>
26
27<hr>
28<!-- Function Prototypes and description -->
29
30<dl>
31<a name="prototypes"></a>
32<dt><pre>
33int <i></i>
34<a name="Cudd_AddHook"><b>Cudd_AddHook</b></a>(
35  DdManager * <b>dd</b>, <i></i>
36  DD_HFP  <b>f</b>, <i></i>
37  Cudd_HookType  <b>where</b> <i></i>
38)
39</pre>
40<dd> Adds a function to a hook. A hook is a list of application-provided functions called on certain occasions by the package. Returns 1 if the function is successfully added; 2 if the function was already in the list; 0 otherwise.
41<p>
42
43<dd> <b>Side Effects</b> None
44<p>
45
46<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_RemoveHook">Cudd_RemoveHook</a>
47</code>
48
49<dt><pre>
50DdApaDigit <i></i>
51<a name="Cudd_ApaAdd"><b>Cudd_ApaAdd</b></a>(
52  int  <b>digits</b>, <i></i>
53  DdApaNumber  <b>a</b>, <i></i>
54  DdApaNumber  <b>b</b>, <i></i>
55  DdApaNumber  <b>sum</b> <i></i>
56)
57</pre>
58<dd> Adds two arbitrary precision integers. Returns the carry out of the most significant digit.
59<p>
60
61<dd> <b>Side Effects</b> The result of the sum is stored in parameter <code>sum</code>.
62<p>
63
64<dt><pre>
65int <i></i>
66<a name="Cudd_ApaCompareRatios"><b>Cudd_ApaCompareRatios</b></a>(
67  int  <b>digitsFirst</b>, <i></i>
68  DdApaNumber  <b>firstNum</b>, <i></i>
69  unsigned int  <b>firstDen</b>, <i></i>
70  int  <b>digitsSecond</b>, <i></i>
71  DdApaNumber  <b>secondNum</b>, <i></i>
72  unsigned int  <b>secondDen</b> <i></i>
73)
74</pre>
75<dd> Compares the ratios of two arbitrary precision integers to two unsigned ints. Returns 1 if the first number is larger; 0 if they are equal; -1 if the second number is larger.
76<p>
77
78<dd> <b>Side Effects</b> None
79<p>
80
81<dt><pre>
82int <i></i>
83<a name="Cudd_ApaCompare"><b>Cudd_ApaCompare</b></a>(
84  int  <b>digitsFirst</b>, <i></i>
85  DdApaNumber  <b>first</b>, <i></i>
86  int  <b>digitsSecond</b>, <i></i>
87  DdApaNumber  <b>second</b> <i></i>
88)
89</pre>
90<dd> Compares two arbitrary precision integers. Returns 1 if the first number is larger; 0 if they are equal; -1 if the second number is larger.
91<p>
92
93<dd> <b>Side Effects</b> None
94<p>
95
96<dt><pre>
97void <i></i>
98<a name="Cudd_ApaCopy"><b>Cudd_ApaCopy</b></a>(
99  int  <b>digits</b>, <i></i>
100  DdApaNumber  <b>source</b>, <i></i>
101  DdApaNumber  <b>dest</b> <i></i>
102)
103</pre>
104<dd> Makes a copy of an arbitrary precision integer.
105<p>
106
107<dd> <b>Side Effects</b> Changes parameter <code>dest</code>.
108<p>
109
110<dt><pre>
111DdApaNumber <i></i>
112<a name="Cudd_ApaCountMinterm"><b>Cudd_ApaCountMinterm</b></a>(
113  DdManager * <b>manager</b>, <i></i>
114  DdNode * <b>node</b>, <i></i>
115  int  <b>nvars</b>, <i></i>
116  int * <b>digits</b> <i></i>
117)
118</pre>
119<dd> Counts the number of minterms of a DD. The function is assumed to depend on nvars variables. The minterm count is represented as an arbitrary precision unsigned integer, to allow for any number of variables CUDD supports. Returns a pointer to the array representing the number of minterms of the function rooted at node if successful; NULL otherwise.
120<p>
121
122<dd> <b>Side Effects</b> The number of digits of the result is returned in parameter <code>digits</code>.
123<p>
124
125<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_CountMinterm">Cudd_CountMinterm</a>
126</code>
127
128<dt><pre>
129unsigned int <i></i>
130<a name="Cudd_ApaIntDivision"><b>Cudd_ApaIntDivision</b></a>(
131  int  <b>digits</b>, <i></i>
132  DdApaNumber  <b>dividend</b>, <i></i>
133  unsigned int  <b>divisor</b>, <i></i>
134  DdApaNumber  <b>quotient</b> <i></i>
135)
136</pre>
137<dd> Divides an arbitrary precision integer by a 32-bit unsigned integer. Returns the remainder of the division. This procedure relies on the assumption that the number of bits of a DdApaDigit plus the number of bits of an unsigned int is less the number of bits of the mantissa of a double. This guarantees that the product of a DdApaDigit and an unsigned int can be represented without loss of precision by a double. On machines where this assumption is not satisfied, this procedure will malfunction.
138<p>
139
140<dd> <b>Side Effects</b> The quotient is returned in parameter <code>quotient</code>.
141<p>
142
143<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_ApaShortDivision">Cudd_ApaShortDivision</a>
144</code>
145
146<dt><pre>
147int <i></i>
148<a name="Cudd_ApaNumberOfDigits"><b>Cudd_ApaNumberOfDigits</b></a>(
149  int  <b>binaryDigits</b> <i></i>
150)
151</pre>
152<dd> Finds the number of digits for an arbitrary precision integer given the maximum number of binary digits. The number of binary digits should be positive. Returns the number of digits if successful; 0 otherwise.
153<p>
154
155<dd> <b>Side Effects</b> None
156<p>
157
158<dt><pre>
159void <i></i>
160<a name="Cudd_ApaPowerOfTwo"><b>Cudd_ApaPowerOfTwo</b></a>(
161  int  <b>digits</b>, <i></i>
162  DdApaNumber  <b>number</b>, <i></i>
163  int  <b>power</b> <i></i>
164)
165</pre>
166<dd> Sets an arbitrary precision integer to a power of two. If the power of two is too large to be represented, the number is set to 0.
167<p>
168
169<dd> <b>Side Effects</b> The result is returned in parameter <code>number</code>.
170<p>
171
172<dt><pre>
173int <i></i>
174<a name="Cudd_ApaPrintDecimal"><b>Cudd_ApaPrintDecimal</b></a>(
175  FILE * <b>fp</b>, <i></i>
176  int  <b>digits</b>, <i></i>
177  DdApaNumber  <b>number</b> <i></i>
178)
179</pre>
180<dd> Prints an arbitrary precision integer in decimal format. Returns 1 if successful; 0 otherwise.
181<p>
182
183<dd> <b>Side Effects</b> None
184<p>
185
186<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_ApaPrintHex">Cudd_ApaPrintHex</a>
187<a href="cuddAllDet.html#Cudd_ApaPrintExponential">Cudd_ApaPrintExponential</a>
188</code>
189
190<dt><pre>
191int <i></i>
192<a name="Cudd_ApaPrintDensity"><b>Cudd_ApaPrintDensity</b></a>(
193  FILE * <b>fp</b>, <i></i>
194  DdManager * <b>dd</b>, <i></i>
195  DdNode * <b>node</b>, <i></i>
196  int  <b>nvars</b> <i></i>
197)
198</pre>
199<dd> Prints the density of a BDD or ADD using arbitrary precision arithmetic. Returns 1 if successful; 0 otherwise.
200<p>
201
202<dd> <b>Side Effects</b> None
203<p>
204
205<dt><pre>
206int <i></i>
207<a name="Cudd_ApaPrintExponential"><b>Cudd_ApaPrintExponential</b></a>(
208  FILE * <b>fp</b>, <i></i>
209  int  <b>digits</b>, <i></i>
210  DdApaNumber  <b>number</b>, <i></i>
211  int  <b>precision</b> <i></i>
212)
213</pre>
214<dd> Prints an arbitrary precision integer in exponential format. Returns 1 if successful; 0 otherwise.
215<p>
216
217<dd> <b>Side Effects</b> None
218<p>
219
220<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_ApaPrintHex">Cudd_ApaPrintHex</a>
221<a href="cuddAllDet.html#Cudd_ApaPrintDecimal">Cudd_ApaPrintDecimal</a>
222</code>
223
224<dt><pre>
225int <i></i>
226<a name="Cudd_ApaPrintHex"><b>Cudd_ApaPrintHex</b></a>(
227  FILE * <b>fp</b>, <i></i>
228  int  <b>digits</b>, <i></i>
229  DdApaNumber  <b>number</b> <i></i>
230)
231</pre>
232<dd> Prints an arbitrary precision integer in hexadecimal format. Returns 1 if successful; 0 otherwise.
233<p>
234
235<dd> <b>Side Effects</b> None
236<p>
237
238<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_ApaPrintDecimal">Cudd_ApaPrintDecimal</a>
239<a href="cuddAllDet.html#Cudd_ApaPrintExponential">Cudd_ApaPrintExponential</a>
240</code>
241
242<dt><pre>
243int <i></i>
244<a name="Cudd_ApaPrintMintermExp"><b>Cudd_ApaPrintMintermExp</b></a>(
245  FILE * <b>fp</b>, <i></i>
246  DdManager * <b>dd</b>, <i></i>
247  DdNode * <b>node</b>, <i></i>
248  int  <b>nvars</b>, <i></i>
249  int  <b>precision</b> <i></i>
250)
251</pre>
252<dd> Prints the number of minterms of a BDD or ADD in exponential format using arbitrary precision arithmetic. Parameter precision controls the number of signficant digits printed. Returns 1 if successful; 0 otherwise.
253<p>
254
255<dd> <b>Side Effects</b> None
256<p>
257
258<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_ApaPrintMinterm">Cudd_ApaPrintMinterm</a>
259</code>
260
261<dt><pre>
262int <i></i>
263<a name="Cudd_ApaPrintMinterm"><b>Cudd_ApaPrintMinterm</b></a>(
264  FILE * <b>fp</b>, <i></i>
265  DdManager * <b>dd</b>, <i></i>
266  DdNode * <b>node</b>, <i></i>
267  int  <b>nvars</b> <i></i>
268)
269</pre>
270<dd> Prints the number of minterms of a BDD or ADD using arbitrary precision arithmetic. Returns 1 if successful; 0 otherwise.
271<p>
272
273<dd> <b>Side Effects</b> None
274<p>
275
276<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_ApaPrintMintermExp">Cudd_ApaPrintMintermExp</a>
277</code>
278
279<dt><pre>
280void <i></i>
281<a name="Cudd_ApaSetToLiteral"><b>Cudd_ApaSetToLiteral</b></a>(
282  int  <b>digits</b>, <i></i>
283  DdApaNumber  <b>number</b>, <i></i>
284  DdApaDigit  <b>literal</b> <i></i>
285)
286</pre>
287<dd> Sets an arbitrary precision integer to a one-digit literal.
288<p>
289
290<dd> <b>Side Effects</b> The result is returned in parameter <code>number</code>.
291<p>
292
293<dt><pre>
294void <i></i>
295<a name="Cudd_ApaShiftRight"><b>Cudd_ApaShiftRight</b></a>(
296  int  <b>digits</b>, <i></i>
297  DdApaDigit  <b>in</b>, <i></i>
298  DdApaNumber  <b>a</b>, <i></i>
299  DdApaNumber  <b>b</b> <i></i>
300)
301</pre>
302<dd> Shifts right an arbitrary precision integer by one binary place. The most significant binary digit of the result is taken from parameter <code>in</code>.
303<p>
304
305<dd> <b>Side Effects</b> The result is returned in parameter <code>b</code>.
306<p>
307
308<dt><pre>
309DdApaDigit <i></i>
310<a name="Cudd_ApaShortDivision"><b>Cudd_ApaShortDivision</b></a>(
311  int  <b>digits</b>, <i></i>
312  DdApaNumber  <b>dividend</b>, <i></i>
313  DdApaDigit  <b>divisor</b>, <i></i>
314  DdApaNumber  <b>quotient</b> <i></i>
315)
316</pre>
317<dd> Divides an arbitrary precision integer by a digit.
318<p>
319
320<dd> <b>Side Effects</b> The quotient is returned in parameter <code>quotient</code>.
321<p>
322
323<dt><pre>
324DdApaDigit <i></i>
325<a name="Cudd_ApaSubtract"><b>Cudd_ApaSubtract</b></a>(
326  int  <b>digits</b>, <i></i>
327  DdApaNumber  <b>a</b>, <i></i>
328  DdApaNumber  <b>b</b>, <i></i>
329  DdApaNumber  <b>diff</b> <i></i>
330)
331</pre>
332<dd> Subtracts two arbitrary precision integers. Returns the borrow out of the most significant digit.
333<p>
334
335<dd> <b>Side Effects</b> The result of the subtraction is stored in parameter <code>diff</code>.
336<p>
337
338<dt><pre>
339void <i></i>
340<a name="Cudd_AutodynDisableZdd"><b>Cudd_AutodynDisableZdd</b></a>(
341  DdManager * <b>unique</b> <i></i>
342)
343</pre>
344<dd> Disables automatic dynamic reordering of ZDDs.
345<p>
346
347<dd> <b>Side Effects</b> None
348<p>
349
350<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_AutodynEnableZdd">Cudd_AutodynEnableZdd</a>
351<a href="cuddAllDet.html#Cudd_ReorderingStatusZdd">Cudd_ReorderingStatusZdd</a>
352<a href="cuddAllDet.html#Cudd_AutodynDisable">Cudd_AutodynDisable</a>
353</code>
354
355<dt><pre>
356void <i></i>
357<a name="Cudd_AutodynDisable"><b>Cudd_AutodynDisable</b></a>(
358  DdManager * <b>unique</b> <i></i>
359)
360</pre>
361<dd> Disables automatic dynamic reordering.
362<p>
363
364<dd> <b>Side Effects</b> None
365<p>
366
367<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_AutodynEnable">Cudd_AutodynEnable</a>
368<a href="cuddAllDet.html#Cudd_ReorderingStatus">Cudd_ReorderingStatus</a>
369<a href="cuddAllDet.html#Cudd_AutodynDisableZdd">Cudd_AutodynDisableZdd</a>
370</code>
371
372<dt><pre>
373void <i></i>
374<a name="Cudd_AutodynEnableZdd"><b>Cudd_AutodynEnableZdd</b></a>(
375  DdManager * <b>unique</b>, <i></i>
376  Cudd_ReorderingType  <b>method</b> <i></i>
377)
378</pre>
379<dd> Enables automatic dynamic reordering of ZDDs. Parameter method is used to determine the method used for reordering ZDDs. If CUDD_REORDER_SAME is passed, the method is unchanged.
380<p>
381
382<dd> <b>Side Effects</b> None
383<p>
384
385<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_AutodynDisableZdd">Cudd_AutodynDisableZdd</a>
386<a href="cuddAllDet.html#Cudd_ReorderingStatusZdd">Cudd_ReorderingStatusZdd</a>
387<a href="cuddAllDet.html#Cudd_AutodynEnable">Cudd_AutodynEnable</a>
388</code>
389
390<dt><pre>
391void <i></i>
392<a name="Cudd_AutodynEnable"><b>Cudd_AutodynEnable</b></a>(
393  DdManager * <b>unique</b>, <i></i>
394  Cudd_ReorderingType  <b>method</b> <i></i>
395)
396</pre>
397<dd> Enables automatic dynamic reordering of BDDs and ADDs. Parameter method is used to determine the method used for reordering. If CUDD_REORDER_SAME is passed, the method is unchanged.
398<p>
399
400<dd> <b>Side Effects</b> None
401<p>
402
403<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_AutodynDisable">Cudd_AutodynDisable</a>
404<a href="cuddAllDet.html#Cudd_ReorderingStatus">Cudd_ReorderingStatus</a>
405<a href="cuddAllDet.html#Cudd_AutodynEnableZdd">Cudd_AutodynEnableZdd</a>
406</code>
407
408<dt><pre>
409double <i></i>
410<a name="Cudd_AverageDistance"><b>Cudd_AverageDistance</b></a>(
411  DdManager * <b>dd</b> <i></i>
412)
413</pre>
414<dd> Computes the average distance between adjacent nodes in the manager. Adjacent nodes are node pairs such that the second node is the then child, else child, or next node in the collision list.
415<p>
416
417<dd> <b>Side Effects</b> None
418<p>
419
420<dt><pre>
421DdNode * <i></i>
422<a name="Cudd_BddToAdd"><b>Cudd_BddToAdd</b></a>(
423  DdManager * <b>dd</b>, <i></i>
424  DdNode * <b>B</b> <i></i>
425)
426</pre>
427<dd> Converts a BDD to a 0-1 ADD. Returns a pointer to the resulting ADD if successful; NULL otherwise.
428<p>
429
430<dd> <b>Side Effects</b> None
431<p>
432
433<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_addBddPattern">Cudd_addBddPattern</a>
434<a href="cuddAllDet.html#Cudd_addBddThreshold">Cudd_addBddThreshold</a>
435<a href="cuddAllDet.html#Cudd_addBddInterval">Cudd_addBddInterval</a>
436<a href="cuddAllDet.html#Cudd_addBddStrictThreshold">Cudd_addBddStrictThreshold</a>
437</code>
438
439<dt><pre>
440int <i></i>
441<a name="Cudd_BddToCubeArray"><b>Cudd_BddToCubeArray</b></a>(
442  DdManager * <b>dd</b>, <i></i>
443  DdNode * <b>cube</b>, <i></i>
444  int * <b>array</b> <i></i>
445)
446</pre>
447<dd> Builds a positional array from the BDD of a cube. Array must have one entry for each BDD variable. The positional array has 1 in i-th position if the variable of index i appears in true form in the cube; it has 0 in i-th position if the variable of index i appears in complemented form in the cube; finally, it has 2 in i-th position if the variable of index i does not appear in the cube. Returns 1 if successful (the BDD is indeed a cube); 0 otherwise.
448<p>
449
450<dd> <b>Side Effects</b> The result is in the array passed by reference.
451<p>
452
453<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_CubeArrayToBdd">Cudd_CubeArrayToBdd</a>
454</code>
455
456<dt><pre>
457DdNode * <i></i>
458<a name="Cudd_BiasedOverApprox"><b>Cudd_BiasedOverApprox</b></a>(
459  DdManager * <b>dd</b>, <i>manager</i>
460  DdNode * <b>f</b>, <i>function to be superset</i>
461  DdNode * <b>b</b>, <i>bias function</i>
462  int  <b>numVars</b>, <i>number of variables in the support of f</i>
463  int  <b>threshold</b>, <i>when to stop approximation</i>
464  double  <b>quality1</b>, <i>minimum improvement for accepted changes when b=1</i>
465  double  <b>quality0</b> <i>minimum improvement for accepted changes when b=0</i>
466)
467</pre>
468<dd> Extracts a dense superset from a BDD. The procedure is identical to the underapproximation procedure except for the fact that it works on the complement of the given function. Extracting the subset of the complement function is equivalent to extracting the superset of the function. Returns a pointer to the BDD of the superset if successful. NULL if intermediate result causes the procedure to run out of memory. The parameter numVars is the maximum number of variables to be used in minterm calculation. The optimal number should be as close as possible to the size of the support of f. However, it is safe to pass the value returned by Cudd_ReadSize for numVars when the number of variables is under 1023. If numVars is larger than 1023, it will overflow. If a 0 parameter is passed then the procedure will compute a value which will avoid overflow but will cause underflow with 2046 variables or more.
469<p>
470
471<dd> <b>Side Effects</b> None
472<p>
473
474<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_SupersetHeavyBranch">Cudd_SupersetHeavyBranch</a>
475<a href="cuddAllDet.html#Cudd_SupersetShortPaths">Cudd_SupersetShortPaths</a>
476<a href="cuddAllDet.html#Cudd_RemapOverApprox">Cudd_RemapOverApprox</a>
477<a href="cuddAllDet.html#Cudd_BiasedUnderApprox">Cudd_BiasedUnderApprox</a>
478<a href="cuddAllDet.html#Cudd_ReadSize">Cudd_ReadSize</a>
479</code>
480
481<dt><pre>
482DdNode * <i></i>
483<a name="Cudd_BiasedUnderApprox"><b>Cudd_BiasedUnderApprox</b></a>(
484  DdManager * <b>dd</b>, <i>manager</i>
485  DdNode * <b>f</b>, <i>function to be subset</i>
486  DdNode * <b>b</b>, <i>bias function</i>
487  int  <b>numVars</b>, <i>number of variables in the support of f</i>
488  int  <b>threshold</b>, <i>when to stop approximation</i>
489  double  <b>quality1</b>, <i>minimum improvement for accepted changes when b=1</i>
490  double  <b>quality0</b> <i>minimum improvement for accepted changes when b=0</i>
491)
492</pre>
493<dd> Extracts a dense subset from a BDD. This procedure uses a biased remapping technique and density as the cost function. The bias is a function. This procedure tries to approximate where the bias is 0 and preserve the given function where the bias is 1. Returns a pointer to the BDD of the subset if successful. NULL if the procedure runs out of memory. The parameter numVars is the maximum number of variables to be used in minterm calculation. The optimal number should be as close as possible to the size of the support of f. However, it is safe to pass the value returned by Cudd_ReadSize for numVars when the number of variables is under 1023. If numVars is larger than 1023, it will cause overflow. If a 0 parameter is passed then the procedure will compute a value which will avoid overflow but will cause underflow with 2046 variables or more.
494<p>
495
496<dd> <b>Side Effects</b> None
497<p>
498
499<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_SubsetShortPaths">Cudd_SubsetShortPaths</a>
500<a href="cuddAllDet.html#Cudd_SubsetHeavyBranch">Cudd_SubsetHeavyBranch</a>
501<a href="cuddAllDet.html#Cudd_UnderApprox">Cudd_UnderApprox</a>
502<a href="cuddAllDet.html#Cudd_RemapUnderApprox">Cudd_RemapUnderApprox</a>
503<a href="cuddAllDet.html#Cudd_ReadSize">Cudd_ReadSize</a>
504</code>
505
506<dt><pre>
507DdNode * <i></i>
508<a name="Cudd_CProjection"><b>Cudd_CProjection</b></a>(
509  DdManager * <b>dd</b>, <i></i>
510  DdNode * <b>R</b>, <i></i>
511  DdNode * <b>Y</b> <i></i>
512)
513</pre>
514<dd> Computes the compatible projection of relation R with respect to cube Y. Returns a pointer to the c-projection if successful; NULL otherwise. For a comparison between Cudd_CProjection and Cudd_PrioritySelect, see the documentation of the latter.
515<p>
516
517<dd> <b>Side Effects</b> None
518<p>
519
520<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_PrioritySelect">Cudd_PrioritySelect</a>
521</code>
522
523<dt><pre>
524int <i></i>
525<a name="Cudd_CheckKeys"><b>Cudd_CheckKeys</b></a>(
526  DdManager * <b>table</b> <i></i>
527)
528</pre>
529<dd> Checks for the following conditions: <ul> <li>Wrong sizes of subtables. <li>Wrong number of keys found in unique subtable. <li>Wrong number of dead found in unique subtable. <li>Wrong number of keys found in the constant table <li>Wrong number of dead found in the constant table <li>Wrong number of total slots found <li>Wrong number of maximum keys found <li>Wrong number of total dead found </ul> Reports the average length of non-empty lists. Returns the number of subtables for which the number of keys is wrong.
530<p>
531
532<dd> <b>Side Effects</b> None
533<p>
534
535<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_DebugCheck">Cudd_DebugCheck</a>
536</code>
537
538<dt><pre>
539int <i></i>
540<a name="Cudd_CheckZeroRef"><b>Cudd_CheckZeroRef</b></a>(
541  DdManager * <b>manager</b> <i></i>
542)
543</pre>
544<dd> Checks the unique table for nodes with non-zero reference counts. It is normally called before Cudd_Quit to make sure that there are no memory leaks due to missing Cudd_RecursiveDeref's. Takes into account that reference counts may saturate and that the basic constants and the projection functions are referenced by the manager. Returns the number of nodes with non-zero reference count. (Except for the cases mentioned above.)
545<p>
546
547<dd> <b>Side Effects</b> None
548<p>
549
550<dt><pre>
551int <i></i>
552<a name="Cudd_ClassifySupport"><b>Cudd_ClassifySupport</b></a>(
553  DdManager * <b>dd</b>, <i>manager</i>
554  DdNode * <b>f</b>, <i>first DD</i>
555  DdNode * <b>g</b>, <i>second DD</i>
556  DdNode ** <b>common</b>, <i>cube of shared variables</i>
557  DdNode ** <b>onlyF</b>, <i>cube of variables only in f</i>
558  DdNode ** <b>onlyG</b> <i>cube of variables only in g</i>
559)
560</pre>
561<dd> Classifies the variables in the support of two DDs <code>f</code> and <code>g</code>, depending on whther they appear in both DDs, only in <code>f</code>, or only in <code>g</code>. Returns 1 if successful; 0 otherwise.
562<p>
563
564<dd> <b>Side Effects</b> The cubes of the three classes of variables are returned as side effects.
565<p>
566
567<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_Support">Cudd_Support</a>
568<a href="cuddAllDet.html#Cudd_VectorSupport">Cudd_VectorSupport</a>
569</code>
570
571<dt><pre>
572void <i></i>
573<a name="Cudd_ClearErrorCode"><b>Cudd_ClearErrorCode</b></a>(
574  DdManager * <b>dd</b> <i></i>
575)
576</pre>
577<dd> Clear the error code of a manager.
578<p>
579
580<dd> <b>Side Effects</b> None
581<p>
582
583<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_ReadErrorCode">Cudd_ReadErrorCode</a>
584</code>
585
586<dt><pre>
587double * <i></i>
588<a name="Cudd_CofMinterm"><b>Cudd_CofMinterm</b></a>(
589  DdManager * <b>dd</b>, <i></i>
590  DdNode * <b>node</b> <i></i>
591)
592</pre>
593<dd> Computes the fraction of minterms in the on-set of all the positive cofactors of DD. Returns the pointer to an array of doubles if successful; NULL otherwise. The array has as many positions as there are BDD variables in the manager plus one. The last position of the array contains the fraction of the minterms in the ON-set of the function represented by the BDD or ADD. The other positions of the array hold the variable signatures.
594<p>
595
596<dd> <b>Side Effects</b> None
597<p>
598
599<dt><pre>
600DdNode * <i></i>
601<a name="Cudd_Cofactor"><b>Cudd_Cofactor</b></a>(
602  DdManager * <b>dd</b>, <i></i>
603  DdNode * <b>f</b>, <i></i>
604  DdNode * <b>g</b> <i></i>
605)
606</pre>
607<dd> Computes the cofactor of f with respect to g; g must be the BDD or the ADD of a cube. Returns a pointer to the cofactor if successful; NULL otherwise.
608<p>
609
610<dd> <b>Side Effects</b> None
611<p>
612
613<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_bddConstrain">Cudd_bddConstrain</a>
614<a href="cuddAllDet.html#Cudd_bddRestrict">Cudd_bddRestrict</a>
615</code>
616
617<dt><pre>
618 <i></i>
619<a name="Cudd_Complement"><b>Cudd_Complement</b></a>(
620   <b>node</b> <i></i>
621)
622</pre>
623<dd> Returns the complemented version of a pointer.
624<p>
625
626<dd> <b>Side Effects</b> none
627<p>
628
629<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_Regular">Cudd_Regular</a>
630<a href="cuddAllDet.html#Cudd_IsComplement">Cudd_IsComplement</a>
631</code>
632
633<dt><pre>
634int <i></i>
635<a name="Cudd_CountLeaves"><b>Cudd_CountLeaves</b></a>(
636  DdNode * <b>node</b> <i></i>
637)
638</pre>
639<dd> Counts the number of leaves in a DD. Returns the number of leaves in the DD rooted at node if successful; CUDD_OUT_OF_MEM otherwise.
640<p>
641
642<dd> <b>Side Effects</b> None
643<p>
644
645<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_PrintDebug">Cudd_PrintDebug</a>
646</code>
647
648<dt><pre>
649double <i></i>
650<a name="Cudd_CountMinterm"><b>Cudd_CountMinterm</b></a>(
651  DdManager * <b>manager</b>, <i></i>
652  DdNode * <b>node</b>, <i></i>
653  int  <b>nvars</b> <i></i>
654)
655</pre>
656<dd> Counts the number of minterms of a DD. The function is assumed to depend on nvars variables. The minterm count is represented as a double, to allow for a larger number of variables. Returns the number of minterms of the function rooted at node if successful; (double) CUDD_OUT_OF_MEM otherwise.
657<p>
658
659<dd> <b>Side Effects</b> None
660<p>
661
662<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_PrintDebug">Cudd_PrintDebug</a>
663<a href="cuddAllDet.html#Cudd_CountPath">Cudd_CountPath</a>
664</code>
665
666<dt><pre>
667double <i></i>
668<a name="Cudd_CountPathsToNonZero"><b>Cudd_CountPathsToNonZero</b></a>(
669  DdNode * <b>node</b> <i></i>
670)
671</pre>
672<dd> Counts the number of paths to a non-zero terminal of a DD. The path count is represented as a double, to allow for a larger number of variables. Returns the number of paths of the function rooted at node.
673<p>
674
675<dd> <b>Side Effects</b> None
676<p>
677
678<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_CountMinterm">Cudd_CountMinterm</a>
679<a href="cuddAllDet.html#Cudd_CountPath">Cudd_CountPath</a>
680</code>
681
682<dt><pre>
683double <i></i>
684<a name="Cudd_CountPath"><b>Cudd_CountPath</b></a>(
685  DdNode * <b>node</b> <i></i>
686)
687</pre>
688<dd> Counts the number of paths of a DD. Paths to all terminal nodes are counted. The path count is represented as a double, to allow for a larger number of variables. Returns the number of paths of the function rooted at node if successful; (double) CUDD_OUT_OF_MEM otherwise.
689<p>
690
691<dd> <b>Side Effects</b> None
692<p>
693
694<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_CountMinterm">Cudd_CountMinterm</a>
695</code>
696
697<dt><pre>
698DdNode * <i></i>
699<a name="Cudd_CubeArrayToBdd"><b>Cudd_CubeArrayToBdd</b></a>(
700  DdManager * <b>dd</b>, <i></i>
701  int * <b>array</b> <i></i>
702)
703</pre>
704<dd> Builds a cube from a positional array. The array must have one integer entry for each BDD variable. If the i-th entry is 1, the variable of index i appears in true form in the cube; If the i-th entry is 0, the variable of index i appears complemented in the cube; otherwise the variable does not appear in the cube. Returns a pointer to the BDD for the cube if successful; NULL otherwise.
705<p>
706
707<dd> <b>Side Effects</b> None
708<p>
709
710<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_bddComputeCube">Cudd_bddComputeCube</a>
711<a href="cuddAllDet.html#Cudd_IndicesToCube">Cudd_IndicesToCube</a>
712<a href="cuddAllDet.html#Cudd_BddToCubeArray">Cudd_BddToCubeArray</a>
713</code>
714
715<dt><pre>
716int <i></i>
717<a name="Cudd_DagSize"><b>Cudd_DagSize</b></a>(
718  DdNode * <b>node</b> <i></i>
719)
720</pre>
721<dd> Counts the number of nodes in a DD. Returns the number of nodes in the graph rooted at node.
722<p>
723
724<dd> <b>Side Effects</b> None
725<p>
726
727<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_SharingSize">Cudd_SharingSize</a>
728<a href="cuddAllDet.html#Cudd_PrintDebug">Cudd_PrintDebug</a>
729</code>
730
731<dt><pre>
732int <i></i>
733<a name="Cudd_DeadAreCounted"><b>Cudd_DeadAreCounted</b></a>(
734  DdManager * <b>dd</b> <i></i>
735)
736</pre>
737<dd> Tells whether dead nodes are counted towards triggering reordering. Returns 1 if dead nodes are counted; 0 otherwise.
738<p>
739
740<dd> <b>Side Effects</b> None
741<p>
742
743<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_TurnOnCountDead">Cudd_TurnOnCountDead</a>
744<a href="cuddAllDet.html#Cudd_TurnOffCountDead">Cudd_TurnOffCountDead</a>
745</code>
746
747<dt><pre>
748int <i></i>
749<a name="Cudd_DebugCheck"><b>Cudd_DebugCheck</b></a>(
750  DdManager * <b>table</b> <i></i>
751)
752</pre>
753<dd> Checks for inconsistencies in the DD heap: <ul> <li> node has illegal index <li> live node has dead children <li> node has illegal Then or Else pointers <li> BDD/ADD node has identical children <li> ZDD node has zero then child <li> wrong number of total nodes <li> wrong number of dead nodes <li> ref count error at node </ul> Returns 0 if no inconsistencies are found; DD_OUT_OF_MEM if there is not enough memory; 1 otherwise.
754<p>
755
756<dd> <b>Side Effects</b> None
757<p>
758
759<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_CheckKeys">Cudd_CheckKeys</a>
760</code>
761
762<dt><pre>
763DdNode * <i></i>
764<a name="Cudd_Decreasing"><b>Cudd_Decreasing</b></a>(
765  DdManager * <b>dd</b>, <i></i>
766  DdNode * <b>f</b>, <i></i>
767  int  <b>i</b> <i></i>
768)
769</pre>
770<dd> Determines whether the function represented by BDD f is negative unate (monotonic decreasing) in variable i. Returns the constant one is f is unate and the (logical) constant zero if it is not. This function does not generate any new nodes.
771<p>
772
773<dd> <b>Side Effects</b> None
774<p>
775
776<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_Increasing">Cudd_Increasing</a>
777</code>
778
779<dt><pre>
780void <i></i>
781<a name="Cudd_DelayedDerefBdd"><b>Cudd_DelayedDerefBdd</b></a>(
782  DdManager * <b>table</b>, <i></i>
783  DdNode * <b>n</b> <i></i>
784)
785</pre>
786<dd> Enqueues node n for later dereferencing. If the queue is full decreases the reference count of the oldest node N to make room for n. If N dies, recursively decreases the reference counts of its children. It is used to dispose of a BDD that is currently not needed, but may be useful again in the near future. The dereferencing proper is done as in Cudd_IterDerefBdd.
787<p>
788
789<dd> <b>Side Effects</b> None
790<p>
791
792<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_RecursiveDeref">Cudd_RecursiveDeref</a>
793<a href="cuddAllDet.html#Cudd_IterDerefBdd">Cudd_IterDerefBdd</a>
794</code>
795
796<dt><pre>
797double <i></i>
798<a name="Cudd_Density"><b>Cudd_Density</b></a>(
799  DdManager * <b>dd</b>, <i>manager</i>
800  DdNode * <b>f</b>, <i>function whose density is sought</i>
801  int  <b>nvars</b> <i>size of the support of f</i>
802)
803</pre>
804<dd> Computes the density of a BDD or ADD. The density is the ratio of the number of minterms to the number of nodes. If 0 is passed as number of variables, the number of variables existing in the manager is used. Returns the density if successful; (double) CUDD_OUT_OF_MEM otherwise.
805<p>
806
807<dd> <b>Side Effects</b> None
808<p>
809
810<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_CountMinterm">Cudd_CountMinterm</a>
811<a href="cuddAllDet.html#Cudd_DagSize">Cudd_DagSize</a>
812</code>
813
814<dt><pre>
815void <i></i>
816<a name="Cudd_Deref"><b>Cudd_Deref</b></a>(
817  DdNode * <b>node</b> <i></i>
818)
819</pre>
820<dd> Decreases the reference count of node. It is primarily used in recursive procedures to decrease the ref count of a result node before returning it. This accomplishes the goal of removing the protection applied by a previous Cudd_Ref.
821<p>
822
823<dd> <b>Side Effects</b> None
824<p>
825
826<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_RecursiveDeref">Cudd_RecursiveDeref</a>
827<a href="cuddAllDet.html#Cudd_RecursiveDerefZdd">Cudd_RecursiveDerefZdd</a>
828<a href="cuddAllDet.html#Cudd_Ref">Cudd_Ref</a>
829</code>
830
831<dt><pre>
832void <i></i>
833<a name="Cudd_DisableGarbageCollection"><b>Cudd_DisableGarbageCollection</b></a>(
834  DdManager * <b>dd</b> <i></i>
835)
836</pre>
837<dd> Disables garbage collection. 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.)
838<p>
839
840<dd> <b>Side Effects</b> None
841<p>
842
843<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_EnableGarbageCollection">Cudd_EnableGarbageCollection</a>
844<a href="cuddAllDet.html#Cudd_GarbageCollectionEnabled">Cudd_GarbageCollectionEnabled</a>
845</code>
846
847<dt><pre>
848int <i></i>
849<a name="Cudd_DisableReorderingReporting"><b>Cudd_DisableReorderingReporting</b></a>(
850  DdManager * <b>dd</b> <i></i>
851)
852</pre>
853<dd> Disables reporting of reordering stats. Returns 1 if successful; 0 otherwise.
854<p>
855
856<dd> <b>Side Effects</b> Removes functions from the pre-reordering and post-reordering hooks.
857<p>
858
859<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_EnableReorderingReporting">Cudd_EnableReorderingReporting</a>
860<a href="cuddAllDet.html#Cudd_ReorderingReporting">Cudd_ReorderingReporting</a>
861</code>
862
863<dt><pre>
864int <i></i>
865<a name="Cudd_DumpBlifBody"><b>Cudd_DumpBlifBody</b></a>(
866  DdManager * <b>dd</b>, <i>manager</i>
867  int  <b>n</b>, <i>number of output nodes to be dumped</i>
868  DdNode ** <b>f</b>, <i>array of output nodes to be dumped</i>
869  char ** <b>inames</b>, <i>array of input names (or NULL)</i>
870  char ** <b>onames</b>, <i>array of output names (or NULL)</i>
871  FILE * <b>fp</b> <i>pointer to the dump file</i>
872)
873</pre>
874<dd> Writes a blif body representing the argument BDDs as a network of multiplexers. No header (.model, .inputs, and .outputs) and footer (.end) are produced by this function. One multiplexer is written for each BDD node. It returns 1 in case of success; 0 otherwise (e.g., out-of-memory, file system full, or an ADD with constants different from 0 and 1). Cudd_DumpBlifBody does not close the file: This is the caller responsibility. Cudd_DumpBlifBody uses a minimal unique subset of the hexadecimal address of a node as name for it. If the argument inames is non-null, it is assumed to hold the pointers to the names of the inputs. Similarly for onames. This function prints out only .names part.
875<p>
876
877<dd> <b>Side Effects</b> None
878<p>
879
880<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_DumpBlif">Cudd_DumpBlif</a>
881<a href="cuddAllDet.html#Cudd_DumpDot">Cudd_DumpDot</a>
882<a href="cuddAllDet.html#Cudd_PrintDebug">Cudd_PrintDebug</a>
883<a href="cuddAllDet.html#Cudd_DumpDDcal">Cudd_DumpDDcal</a>
884<a href="cuddAllDet.html#Cudd_DumpDaVinci">Cudd_DumpDaVinci</a>
885<a href="cuddAllDet.html#Cudd_DumpFactoredForm">Cudd_DumpFactoredForm</a>
886</code>
887
888<dt><pre>
889int <i></i>
890<a name="Cudd_DumpBlif"><b>Cudd_DumpBlif</b></a>(
891  DdManager * <b>dd</b>, <i>manager</i>
892  int  <b>n</b>, <i>number of output nodes to be dumped</i>
893  DdNode ** <b>f</b>, <i>array of output nodes to be dumped</i>
894  char ** <b>inames</b>, <i>array of input names (or NULL)</i>
895  char ** <b>onames</b>, <i>array of output names (or NULL)</i>
896  char * <b>mname</b>, <i>model name (or NULL)</i>
897  FILE * <b>fp</b> <i>pointer to the dump file</i>
898)
899</pre>
900<dd> Writes a blif file representing the argument BDDs as a network of multiplexers. One multiplexer is written for each BDD node. It returns 1 in case of success; 0 otherwise (e.g., out-of-memory, file system full, or an ADD with constants different from 0 and 1). Cudd_DumpBlif does not close the file: This is the caller responsibility. Cudd_DumpBlif uses a minimal unique subset of the hexadecimal address of a node as name for it. If the argument inames is non-null, it is assumed to hold the pointers to the names of the inputs. Similarly for onames.
901<p>
902
903<dd> <b>Side Effects</b> None
904<p>
905
906<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_DumpBlifBody">Cudd_DumpBlifBody</a>
907<a href="cuddAllDet.html#Cudd_DumpDot">Cudd_DumpDot</a>
908<a href="cuddAllDet.html#Cudd_PrintDebug">Cudd_PrintDebug</a>
909<a href="cuddAllDet.html#Cudd_DumpDDcal">Cudd_DumpDDcal</a>
910<a href="cuddAllDet.html#Cudd_DumpDaVinci">Cudd_DumpDaVinci</a>
911<a href="cuddAllDet.html#Cudd_DumpFactoredForm">Cudd_DumpFactoredForm</a>
912</code>
913
914<dt><pre>
915int <i></i>
916<a name="Cudd_DumpDDcal"><b>Cudd_DumpDDcal</b></a>(
917  DdManager * <b>dd</b>, <i>manager</i>
918  int  <b>n</b>, <i>number of output nodes to be dumped</i>
919  DdNode ** <b>f</b>, <i>array of output nodes to be dumped</i>
920  char ** <b>inames</b>, <i>array of input names (or NULL)</i>
921  char ** <b>onames</b>, <i>array of output names (or NULL)</i>
922  FILE * <b>fp</b> <i>pointer to the dump file</i>
923)
924</pre>
925<dd> Writes a DDcal file representing the argument BDDs. It returns 1 in case of success; 0 otherwise (e.g., out-of-memory or file system full). Cudd_DumpDDcal does not close the file: This is the caller responsibility. Cudd_DumpDDcal uses a minimal unique subset of the hexadecimal address of a node as name for it. If the argument inames is non-null, it is assumed to hold the pointers to the names of the inputs. Similarly for onames.
926<p>
927
928<dd> <b>Side Effects</b> None
929<p>
930
931<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_DumpDot">Cudd_DumpDot</a>
932<a href="cuddAllDet.html#Cudd_PrintDebug">Cudd_PrintDebug</a>
933<a href="cuddAllDet.html#Cudd_DumpBlif">Cudd_DumpBlif</a>
934<a href="cuddAllDet.html#Cudd_DumpDaVinci">Cudd_DumpDaVinci</a>
935<a href="cuddAllDet.html#Cudd_DumpFactoredForm">Cudd_DumpFactoredForm</a>
936</code>
937
938<dt><pre>
939int <i></i>
940<a name="Cudd_DumpDaVinci"><b>Cudd_DumpDaVinci</b></a>(
941  DdManager * <b>dd</b>, <i>manager</i>
942  int  <b>n</b>, <i>number of output nodes to be dumped</i>
943  DdNode ** <b>f</b>, <i>array of output nodes to be dumped</i>
944  char ** <b>inames</b>, <i>array of input names (or NULL)</i>
945  char ** <b>onames</b>, <i>array of output names (or NULL)</i>
946  FILE * <b>fp</b> <i>pointer to the dump file</i>
947)
948</pre>
949<dd> Writes a daVinci file representing the argument BDDs. It returns 1 in case of success; 0 otherwise (e.g., out-of-memory or file system full). Cudd_DumpDaVinci does not close the file: This is the caller responsibility. Cudd_DumpDaVinci uses a minimal unique subset of the hexadecimal address of a node as name for it. If the argument inames is non-null, it is assumed to hold the pointers to the names of the inputs. Similarly for onames.
950<p>
951
952<dd> <b>Side Effects</b> None
953<p>
954
955<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_DumpDot">Cudd_DumpDot</a>
956<a href="cuddAllDet.html#Cudd_PrintDebug">Cudd_PrintDebug</a>
957<a href="cuddAllDet.html#Cudd_DumpBlif">Cudd_DumpBlif</a>
958<a href="cuddAllDet.html#Cudd_DumpDDcal">Cudd_DumpDDcal</a>
959<a href="cuddAllDet.html#Cudd_DumpFactoredForm">Cudd_DumpFactoredForm</a>
960</code>
961
962<dt><pre>
963int <i></i>
964<a name="Cudd_DumpDot"><b>Cudd_DumpDot</b></a>(
965  DdManager * <b>dd</b>, <i>manager</i>
966  int  <b>n</b>, <i>number of output nodes to be dumped</i>
967  DdNode ** <b>f</b>, <i>array of output nodes to be dumped</i>
968  char ** <b>inames</b>, <i>array of input names (or NULL)</i>
969  char ** <b>onames</b>, <i>array of output names (or NULL)</i>
970  FILE * <b>fp</b> <i>pointer to the dump file</i>
971)
972</pre>
973<dd> Writes a file representing the argument DDs in a format suitable for the graph drawing program dot. It returns 1 in case of success; 0 otherwise (e.g., out-of-memory, file system full). Cudd_DumpDot does not close the file: This is the caller responsibility. Cudd_DumpDot uses a minimal unique subset of the hexadecimal address of a node as name for it. If the argument inames is non-null, it is assumed to hold the pointers to the names of the inputs. Similarly for onames. Cudd_DumpDot uses the following convention to draw arcs: <ul> <li> solid line: THEN arcs; <li> dotted line: complement arcs; <li> dashed line: regular ELSE arcs. </ul> The dot options are chosen so that the drawing fits on a letter-size sheet.
974<p>
975
976<dd> <b>Side Effects</b> None
977<p>
978
979<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_DumpBlif">Cudd_DumpBlif</a>
980<a href="cuddAllDet.html#Cudd_PrintDebug">Cudd_PrintDebug</a>
981<a href="cuddAllDet.html#Cudd_DumpDDcal">Cudd_DumpDDcal</a>
982<a href="cuddAllDet.html#Cudd_DumpDaVinci">Cudd_DumpDaVinci</a>
983<a href="cuddAllDet.html#Cudd_DumpFactoredForm">Cudd_DumpFactoredForm</a>
984</code>
985
986<dt><pre>
987int <i></i>
988<a name="Cudd_DumpFactoredForm"><b>Cudd_DumpFactoredForm</b></a>(
989  DdManager * <b>dd</b>, <i>manager</i>
990  int  <b>n</b>, <i>number of output nodes to be dumped</i>
991  DdNode ** <b>f</b>, <i>array of output nodes to be dumped</i>
992  char ** <b>inames</b>, <i>array of input names (or NULL)</i>
993  char ** <b>onames</b>, <i>array of output names (or NULL)</i>
994  FILE * <b>fp</b> <i>pointer to the dump file</i>
995)
996</pre>
997<dd> Writes factored forms representing the argument BDDs. The format of the factored form is the one used in the genlib files for technology mapping in sis. It returns 1 in case of success; 0 otherwise (e.g., file system full). Cudd_DumpFactoredForm does not close the file: This is the caller responsibility. Caution must be exercised because a factored form may be exponentially larger than the argument BDD. If the argument inames is non-null, it is assumed to hold the pointers to the names of the inputs. Similarly for onames.
998<p>
999
1000<dd> <b>Side Effects</b> None
1001<p>
1002
1003<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_DumpDot">Cudd_DumpDot</a>
1004<a href="cuddAllDet.html#Cudd_PrintDebug">Cudd_PrintDebug</a>
1005<a href="cuddAllDet.html#Cudd_DumpBlif">Cudd_DumpBlif</a>
1006<a href="cuddAllDet.html#Cudd_DumpDaVinci">Cudd_DumpDaVinci</a>
1007<a href="cuddAllDet.html#Cudd_DumpDDcal">Cudd_DumpDDcal</a>
1008</code>
1009
1010<dt><pre>
1011DdNode * <i></i>
1012<a name="Cudd_Dxygtdxz"><b>Cudd_Dxygtdxz</b></a>(
1013  DdManager * <b>dd</b>, <i>DD manager</i>
1014  int  <b>N</b>, <i>number of x, y, and z variables</i>
1015  DdNode ** <b>x</b>, <i>array of x variables</i>
1016  DdNode ** <b>y</b>, <i>array of y variables</i>
1017  DdNode ** <b>z</b> <i>array of z variables</i>
1018)
1019</pre>
1020<dd> This function generates a BDD for the function d(x,y) &gt; d(x,z); x, y, and z are N-bit numbers, x[0] x[1] ... x[N-1], y[0] y[1] ... y[N-1], and z[0] z[1] ... z[N-1], with 0 the most significant bit. The distance d(x,y) is defined as: sum_{i=0}^{N-1}(|x_i - y_i| cdot 2^{N-i-1}). The BDD is built bottom-up. It has 7*N-3 internal nodes, if the variables are ordered as follows: x[0] y[0] z[0] x[1] y[1] z[1] ... x[N-1] y[N-1] z[N-1].
1021<p>
1022
1023<dd> <b>Side Effects</b> None
1024<p>
1025
1026<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_PrioritySelect">Cudd_PrioritySelect</a>
1027<a href="cuddAllDet.html#Cudd_Dxygtdyz">Cudd_Dxygtdyz</a>
1028<a href="cuddAllDet.html#Cudd_Xgty">Cudd_Xgty</a>
1029<a href="cuddAllDet.html#Cudd_bddAdjPermuteX">Cudd_bddAdjPermuteX</a>
1030</code>
1031
1032<dt><pre>
1033DdNode * <i></i>
1034<a name="Cudd_Dxygtdyz"><b>Cudd_Dxygtdyz</b></a>(
1035  DdManager * <b>dd</b>, <i>DD manager</i>
1036  int  <b>N</b>, <i>number of x, y, and z variables</i>
1037  DdNode ** <b>x</b>, <i>array of x variables</i>
1038  DdNode ** <b>y</b>, <i>array of y variables</i>
1039  DdNode ** <b>z</b> <i>array of z variables</i>
1040)
1041</pre>
1042<dd> This function generates a BDD for the function d(x,y) &gt; d(y,z); x, y, and z are N-bit numbers, x[0] x[1] ... x[N-1], y[0] y[1] ... y[N-1], and z[0] z[1] ... z[N-1], with 0 the most significant bit. The distance d(x,y) is defined as: sum_{i=0}^{N-1}(|x_i - y_i| cdot 2^{N-i-1}). The BDD is built bottom-up. It has 7*N-3 internal nodes, if the variables are ordered as follows: x[0] y[0] z[0] x[1] y[1] z[1] ... x[N-1] y[N-1] z[N-1].
1043<p>
1044
1045<dd> <b>Side Effects</b> None
1046<p>
1047
1048<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_PrioritySelect">Cudd_PrioritySelect</a>
1049<a href="cuddAllDet.html#Cudd_Dxygtdxz">Cudd_Dxygtdxz</a>
1050<a href="cuddAllDet.html#Cudd_Xgty">Cudd_Xgty</a>
1051<a href="cuddAllDet.html#Cudd_bddAdjPermuteX">Cudd_bddAdjPermuteX</a>
1052</code>
1053
1054<dt><pre>
1055void <i></i>
1056<a name="Cudd_EnableGarbageCollection"><b>Cudd_EnableGarbageCollection</b></a>(
1057  DdManager * <b>dd</b> <i></i>
1058)
1059</pre>
1060<dd> Enables garbage collection. Garbage collection is initially enabled. Therefore it is necessary to call this function only if garbage collection has been explicitly disabled.
1061<p>
1062
1063<dd> <b>Side Effects</b> None
1064<p>
1065
1066<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_DisableGarbageCollection">Cudd_DisableGarbageCollection</a>
1067<a href="cuddAllDet.html#Cudd_GarbageCollectionEnabled">Cudd_GarbageCollectionEnabled</a>
1068</code>
1069
1070<dt><pre>
1071int <i></i>
1072<a name="Cudd_EnableReorderingReporting"><b>Cudd_EnableReorderingReporting</b></a>(
1073  DdManager * <b>dd</b> <i></i>
1074)
1075</pre>
1076<dd> Enables reporting of reordering stats. Returns 1 if successful; 0 otherwise.
1077<p>
1078
1079<dd> <b>Side Effects</b> Installs functions in the pre-reordering and post-reordering hooks.
1080<p>
1081
1082<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_DisableReorderingReporting">Cudd_DisableReorderingReporting</a>
1083<a href="cuddAllDet.html#Cudd_ReorderingReporting">Cudd_ReorderingReporting</a>
1084</code>
1085
1086<dt><pre>
1087int <i></i>
1088<a name="Cudd_EpdCountMinterm"><b>Cudd_EpdCountMinterm</b></a>(
1089  DdManager * <b>manager</b>, <i></i>
1090  DdNode * <b>node</b>, <i></i>
1091  int  <b>nvars</b>, <i></i>
1092  EpDouble * <b>epd</b> <i></i>
1093)
1094</pre>
1095<dd> Counts the number of minterms of a DD with extended precision. The function is assumed to depend on nvars variables. The minterm count is represented as an EpDouble, to allow any number of variables. Returns 0 if successful; CUDD_OUT_OF_MEM otherwise.
1096<p>
1097
1098<dd> <b>Side Effects</b> None
1099<p>
1100
1101<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_PrintDebug">Cudd_PrintDebug</a>
1102<a href="cuddAllDet.html#Cudd_CountPath">Cudd_CountPath</a>
1103</code>
1104
1105<dt><pre>
1106int <i></i>
1107<a name="Cudd_EqualSupNorm"><b>Cudd_EqualSupNorm</b></a>(
1108  DdManager * <b>dd</b>, <i>manager</i>
1109  DdNode * <b>f</b>, <i>first ADD</i>
1110  DdNode * <b>g</b>, <i>second ADD</i>
1111  CUDD_VALUE_TYPE  <b>tolerance</b>, <i>maximum allowed difference</i>
1112  int  <b>pr</b> <i>verbosity level</i>
1113)
1114</pre>
1115<dd> Compares two ADDs for equality within tolerance. Two ADDs are reported to be equal if the maximum difference between them (the sup norm of their difference) is less than or equal to the tolerance parameter. Returns 1 if the two ADDs are equal (within tolerance); 0 otherwise. If parameter <code>pr</code> is positive the first failure is reported to the standard output.
1116<p>
1117
1118<dd> <b>Side Effects</b> None
1119<p>
1120
1121<dt><pre>
1122int <i></i>
1123<a name="Cudd_EquivDC"><b>Cudd_EquivDC</b></a>(
1124  DdManager * <b>dd</b>, <i></i>
1125  DdNode * <b>F</b>, <i></i>
1126  DdNode * <b>G</b>, <i></i>
1127  DdNode * <b>D</b> <i></i>
1128)
1129</pre>
1130<dd> Tells whether F and G are identical wherever D is 0. F and G are either two ADDs or two BDDs. D is either a 0-1 ADD or a BDD. The function returns 1 if F and G are equivalent, and 0 otherwise. No new nodes are created.
1131<p>
1132
1133<dd> <b>Side Effects</b> None
1134<p>
1135
1136<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_bddLeqUnless">Cudd_bddLeqUnless</a>
1137</code>
1138
1139<dt><pre>
1140int <i></i>
1141<a name="Cudd_EstimateCofactorSimple"><b>Cudd_EstimateCofactorSimple</b></a>(
1142  DdNode * <b>node</b>, <i></i>
1143  int  <b>i</b> <i></i>
1144)
1145</pre>
1146<dd> Estimates the number of nodes in a cofactor of a DD. Returns an estimate of the number of nodes in the positive cofactor of the graph rooted at node with respect to the variable whose index is i. This procedure implements with minor changes the algorithm of Cabodi et al. (ICCAD96). It does not allocate any memory, it does not change the state of the manager, and it is fast. However, it has been observed to overestimate the size of the cofactor by as much as a factor of 2.
1147<p>
1148
1149<dd> <b>Side Effects</b> None
1150<p>
1151
1152<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_DagSize">Cudd_DagSize</a>
1153</code>
1154
1155<dt><pre>
1156int <i></i>
1157<a name="Cudd_EstimateCofactor"><b>Cudd_EstimateCofactor</b></a>(
1158  DdManager * <b>dd</b>, <i>manager</i>
1159  DdNode * <b>f</b>, <i>function</i>
1160  int  <b>i</b>, <i>index of variable</i>
1161  int  <b>phase</b> <i>1: positive; 0: negative</i>
1162)
1163</pre>
1164<dd> Estimates the number of nodes in a cofactor of a DD. Returns an estimate of the number of nodes in a cofactor of the graph rooted at node with respect to the variable whose index is i. In case of failure, returns CUDD_OUT_OF_MEM. This function uses a refinement of the algorithm of Cabodi et al. (ICCAD96). The refinement allows the procedure to account for part of the recombination that may occur in the part of the cofactor above the cofactoring variable. This procedure does no create any new node. It does keep a small table of results; therefore it may run out of memory. If this is a concern, one should use Cudd_EstimateCofactorSimple, which is faster, does not allocate any memory, but is less accurate.
1165<p>
1166
1167<dd> <b>Side Effects</b> None
1168<p>
1169
1170<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_DagSize">Cudd_DagSize</a>
1171<a href="cuddAllDet.html#Cudd_EstimateCofactorSimple">Cudd_EstimateCofactorSimple</a>
1172</code>
1173
1174<dt><pre>
1175DdNode * <i></i>
1176<a name="Cudd_Eval"><b>Cudd_Eval</b></a>(
1177  DdManager * <b>dd</b>, <i></i>
1178  DdNode * <b>f</b>, <i></i>
1179  int * <b>inputs</b> <i></i>
1180)
1181</pre>
1182<dd> Finds the value of a DD for a given variable assignment. The variable assignment is passed in an array of int's, that should specify a zero or a one for each variable in the support of the function. Returns a pointer to a constant node. No new nodes are produced.
1183<p>
1184
1185<dd> <b>Side Effects</b> None
1186<p>
1187
1188<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_bddLeq">Cudd_bddLeq</a>
1189<a href="cuddAllDet.html#Cudd_addEvalConst">Cudd_addEvalConst</a>
1190</code>
1191
1192<dt><pre>
1193double <i></i>
1194<a name="Cudd_ExpectedUsedSlots"><b>Cudd_ExpectedUsedSlots</b></a>(
1195  DdManager * <b>dd</b> <i></i>
1196)
1197</pre>
1198<dd> Computes the fraction of slots in the unique table that should be in use. 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.
1199<p>
1200
1201<dd> <b>Side Effects</b> None
1202<p>
1203
1204<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_ReadSlots">Cudd_ReadSlots</a>
1205<a href="cuddAllDet.html#Cudd_ReadUsedSlots">Cudd_ReadUsedSlots</a>
1206</code>
1207
1208<dt><pre>
1209 <i></i>
1210<a name="Cudd_E"><b>Cudd_E</b></a>(
1211   <b>node</b> <i></i>
1212)
1213</pre>
1214<dd> Returns the else child of an internal node. If <code>node</code> is a constant node, the result is unpredictable.
1215<p>
1216
1217<dd> <b>Side Effects</b> none
1218<p>
1219
1220<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_T">Cudd_T</a>
1221<a href="cuddAllDet.html#Cudd_V">Cudd_V</a>
1222</code>
1223
1224<dt><pre>
1225DdNode * <i></i>
1226<a name="Cudd_FindEssential"><b>Cudd_FindEssential</b></a>(
1227  DdManager * <b>dd</b>, <i></i>
1228  DdNode * <b>f</b> <i></i>
1229)
1230</pre>
1231<dd> Returns the cube of the essential variables. A positive literal means that the variable must be set to 1 for the function to be 1. A negative literal means that the variable must be set to 0 for the function to be 1. Returns a pointer to the cube BDD if successful; NULL otherwise.
1232<p>
1233
1234<dd> <b>Side Effects</b> None
1235<p>
1236
1237<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_bddIsVarEssential">Cudd_bddIsVarEssential</a>
1238</code>
1239
1240<dt><pre>
1241DdTlcInfo * <i></i>
1242<a name="Cudd_FindTwoLiteralClauses"><b>Cudd_FindTwoLiteralClauses</b></a>(
1243  DdManager * <b>dd</b>, <i></i>
1244  DdNode * <b>f</b> <i></i>
1245)
1246</pre>
1247<dd> Returns the one- and two-literal clauses of a DD. Returns a pointer to the structure holding the clauses if successful; NULL otherwise. For a constant DD, the empty set of clauses is returned. This is obviously correct for a non-zero constant. For the constant zero, it is based on the assumption that only those clauses containing variables in the support of the function are considered. Since the support of a constant function is empty, no clauses are returned.
1248<p>
1249
1250<dd> <b>Side Effects</b> None
1251<p>
1252
1253<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_FindEssential">Cudd_FindEssential</a>
1254</code>
1255
1256<dt><pre>
1257DdGen * <i></i>
1258<a name="Cudd_FirstCube"><b>Cudd_FirstCube</b></a>(
1259  DdManager * <b>dd</b>, <i></i>
1260  DdNode * <b>f</b>, <i></i>
1261  int ** <b>cube</b>, <i></i>
1262  CUDD_VALUE_TYPE * <b>value</b> <i></i>
1263)
1264</pre>
1265<dd> Defines an iterator on the onset of a decision diagram and finds its first cube. Returns a generator that contains the information necessary to continue the enumeration if successful; NULL otherwise.<p> A cube is represented as an array of literals, which are integers in {0, 1, 2}; 0 represents a complemented literal, 1 represents an uncomplemented literal, and 2 stands for don't care. The enumeration produces a disjoint cover of the function associated with the diagram. The size of the array equals the number of variables in the manager at the time Cudd_FirstCube is called.<p> For each cube, a value is also returned. This value is always 1 for a BDD, while it may be different from 1 for an ADD. For BDDs, the offset is the set of cubes whose value is the logical zero. For ADDs, the offset is the set of cubes whose value is the background value. The cubes of the offset are not enumerated.
1266<p>
1267
1268<dd> <b>Side Effects</b> The first cube and its value are returned as side effects.
1269<p>
1270
1271<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_ForeachCube">Cudd_ForeachCube</a>
1272<a href="cuddAllDet.html#Cudd_NextCube">Cudd_NextCube</a>
1273<a href="cuddAllDet.html#Cudd_GenFree">Cudd_GenFree</a>
1274<a href="cuddAllDet.html#Cudd_IsGenEmpty">Cudd_IsGenEmpty</a>
1275<a href="cuddAllDet.html#Cudd_FirstNode">Cudd_FirstNode</a>
1276</code>
1277
1278<dt><pre>
1279DdGen * <i></i>
1280<a name="Cudd_FirstNode"><b>Cudd_FirstNode</b></a>(
1281  DdManager * <b>dd</b>, <i></i>
1282  DdNode * <b>f</b>, <i></i>
1283  DdNode ** <b>node</b> <i></i>
1284)
1285</pre>
1286<dd> Defines an iterator on the nodes of a decision diagram and finds its first node. Returns a generator that contains the information necessary to continue the enumeration if successful; NULL otherwise. The nodes are enumerated in a reverse topological order, so that a node is always preceded in the enumeration by its descendants.
1287<p>
1288
1289<dd> <b>Side Effects</b> The first node is returned as a side effect.
1290<p>
1291
1292<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_ForeachNode">Cudd_ForeachNode</a>
1293<a href="cuddAllDet.html#Cudd_NextNode">Cudd_NextNode</a>
1294<a href="cuddAllDet.html#Cudd_GenFree">Cudd_GenFree</a>
1295<a href="cuddAllDet.html#Cudd_IsGenEmpty">Cudd_IsGenEmpty</a>
1296<a href="cuddAllDet.html#Cudd_FirstCube">Cudd_FirstCube</a>
1297</code>
1298
1299<dt><pre>
1300DdGen * <i></i>
1301<a name="Cudd_FirstPrime"><b>Cudd_FirstPrime</b></a>(
1302  DdManager * <b>dd</b>, <i></i>
1303  DdNode * <b>l</b>, <i></i>
1304  DdNode * <b>u</b>, <i></i>
1305  int ** <b>cube</b> <i></i>
1306)
1307</pre>
1308<dd> Defines an iterator on a pair of BDDs describing a (possibly incompletely specified) Boolean functions and finds the first cube of a cover of the function. Returns a generator that contains the information necessary to continue the enumeration if successful; NULL otherwise.<p> The two argument BDDs are the lower and upper bounds of an interval. It is a mistake to call this function with a lower bound that is not less than or equal to the upper bound.<p> A cube is represented as an array of literals, which are integers in {0, 1, 2}; 0 represents a complemented literal, 1 represents an uncomplemented literal, and 2 stands for don't care. The enumeration produces a prime and irredundant cover of the function associated with the two BDDs. The size of the array equals the number of variables in the manager at the time Cudd_FirstCube is called.<p> This iterator can only be used on BDDs.
1309<p>
1310
1311<dd> <b>Side Effects</b> The first cube is returned as side effect.
1312<p>
1313
1314<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_ForeachPrime">Cudd_ForeachPrime</a>
1315<a href="cuddAllDet.html#Cudd_NextPrime">Cudd_NextPrime</a>
1316<a href="cuddAllDet.html#Cudd_GenFree">Cudd_GenFree</a>
1317<a href="cuddAllDet.html#Cudd_IsGenEmpty">Cudd_IsGenEmpty</a>
1318<a href="cuddAllDet.html#Cudd_FirstCube">Cudd_FirstCube</a>
1319<a href="cuddAllDet.html#Cudd_FirstNode">Cudd_FirstNode</a>
1320</code>
1321
1322<dt><pre>
1323 <i></i>
1324<a name="Cudd_ForeachCube"><b>Cudd_ForeachCube</b></a>(
1325   <b>manager</b>, <i></i>
1326   <b>f</b>, <i></i>
1327   <b>gen</b>, <i></i>
1328   <b>cube</b>, <i></i>
1329   <b>value</b> <i></i>
1330)
1331</pre>
1332<dd> Iterates over the cubes of a decision diagram f. <ul> <li> DdManager *manager; <li> DdNode *f; <li> DdGen *gen; <li> int *cube; <li> CUDD_VALUE_TYPE value; </ul> Cudd_ForeachCube allocates and frees the generator. Therefore the application should not try to do that. Also, the cube is freed at the end of Cudd_ForeachCube and hence is not available outside of the loop.<p> CAUTION: It is assumed that dynamic reordering will not occur while there are open generators. It is the user's responsibility to make sure that dynamic reordering does not occur. As long as new nodes are not created during generation, and dynamic reordering is not called explicitly, dynamic reordering will not occur. Alternatively, it is sufficient to disable dynamic reordering. It is a mistake to dispose of a diagram on which generation is ongoing.
1333<p>
1334
1335<dd> <b>Side Effects</b> none
1336<p>
1337
1338<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_ForeachNode">Cudd_ForeachNode</a>
1339<a href="cuddAllDet.html#Cudd_FirstCube">Cudd_FirstCube</a>
1340<a href="cuddAllDet.html#Cudd_NextCube">Cudd_NextCube</a>
1341<a href="cuddAllDet.html#Cudd_GenFree">Cudd_GenFree</a>
1342<a href="cuddAllDet.html#Cudd_IsGenEmpty">Cudd_IsGenEmpty</a>
1343<a href="cuddAllDet.html#Cudd_AutodynDisable">Cudd_AutodynDisable</a>
1344</code>
1345
1346<dt><pre>
1347 <i></i>
1348<a name="Cudd_ForeachNode"><b>Cudd_ForeachNode</b></a>(
1349   <b>manager</b>, <i></i>
1350   <b>f</b>, <i></i>
1351   <b>gen</b>, <i></i>
1352   <b>node</b> <i></i>
1353)
1354</pre>
1355<dd> Iterates over the nodes of a decision diagram f. <ul> <li> DdManager *manager; <li> DdNode *f; <li> DdGen *gen; <li> DdNode *node; </ul> The nodes are returned in a seemingly random order. Cudd_ForeachNode allocates and frees the generator. Therefore the application should not try to do that.<p> CAUTION: It is assumed that dynamic reordering will not occur while there are open generators. It is the user's responsibility to make sure that dynamic reordering does not occur. As long as new nodes are not created during generation, and dynamic reordering is not called explicitly, dynamic reordering will not occur. Alternatively, it is sufficient to disable dynamic reordering. It is a mistake to dispose of a diagram on which generation is ongoing.
1356<p>
1357
1358<dd> <b>Side Effects</b> none
1359<p>
1360
1361<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_ForeachCube">Cudd_ForeachCube</a>
1362<a href="cuddAllDet.html#Cudd_FirstNode">Cudd_FirstNode</a>
1363<a href="cuddAllDet.html#Cudd_NextNode">Cudd_NextNode</a>
1364<a href="cuddAllDet.html#Cudd_GenFree">Cudd_GenFree</a>
1365<a href="cuddAllDet.html#Cudd_IsGenEmpty">Cudd_IsGenEmpty</a>
1366<a href="cuddAllDet.html#Cudd_AutodynDisable">Cudd_AutodynDisable</a>
1367</code>
1368
1369<dt><pre>
1370 <i></i>
1371<a name="Cudd_ForeachPrime"><b>Cudd_ForeachPrime</b></a>(
1372   <b>manager</b>, <i></i>
1373   <b>l</b>, <i></i>
1374   <b>u</b>, <i></i>
1375   <b>gen</b>, <i></i>
1376   <b>cube</b> <i></i>
1377)
1378</pre>
1379<dd> Iterates over the primes of a Boolean function producing a prime and irredundant cover. <ul> <li> DdManager *manager; <li> DdNode *l; <li> DdNode *u; <li> DdGen *gen; <li> int *cube; </ul> The Boolean function is described by an upper bound and a lower bound. If the function is completely specified, the two bounds coincide. Cudd_ForeachPrime allocates and frees the generator. Therefore the application should not try to do that. Also, the cube is freed at the end of Cudd_ForeachPrime and hence is not available outside of the loop.<p> CAUTION: It is a mistake to change a diagram on which generation is ongoing.
1380<p>
1381
1382<dd> <b>Side Effects</b> none
1383<p>
1384
1385<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_ForeachCube">Cudd_ForeachCube</a>
1386<a href="cuddAllDet.html#Cudd_FirstPrime">Cudd_FirstPrime</a>
1387<a href="cuddAllDet.html#Cudd_NextPrime">Cudd_NextPrime</a>
1388<a href="cuddAllDet.html#Cudd_GenFree">Cudd_GenFree</a>
1389<a href="cuddAllDet.html#Cudd_IsGenEmpty">Cudd_IsGenEmpty</a>
1390</code>
1391
1392<dt><pre>
1393void <i></i>
1394<a name="Cudd_FreeTree"><b>Cudd_FreeTree</b></a>(
1395  DdManager * <b>dd</b> <i></i>
1396)
1397</pre>
1398<dd> Frees the variable group tree of the manager.
1399<p>
1400
1401<dd> <b>Side Effects</b> None
1402<p>
1403
1404<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_SetTree">Cudd_SetTree</a>
1405<a href="cuddAllDet.html#Cudd_ReadTree">Cudd_ReadTree</a>
1406<a href="cuddAllDet.html#Cudd_FreeZddTree">Cudd_FreeZddTree</a>
1407</code>
1408
1409<dt><pre>
1410void <i></i>
1411<a name="Cudd_FreeZddTree"><b>Cudd_FreeZddTree</b></a>(
1412  DdManager * <b>dd</b> <i></i>
1413)
1414</pre>
1415<dd> Frees the variable group tree of the manager.
1416<p>
1417
1418<dd> <b>Side Effects</b> None
1419<p>
1420
1421<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_SetZddTree">Cudd_SetZddTree</a>
1422<a href="cuddAllDet.html#Cudd_ReadZddTree">Cudd_ReadZddTree</a>
1423<a href="cuddAllDet.html#Cudd_FreeTree">Cudd_FreeTree</a>
1424</code>
1425
1426<dt><pre>
1427int <i></i>
1428<a name="Cudd_GarbageCollectionEnabled"><b>Cudd_GarbageCollectionEnabled</b></a>(
1429  DdManager * <b>dd</b> <i></i>
1430)
1431</pre>
1432<dd> Returns 1 if garbage collection is enabled; 0 otherwise.
1433<p>
1434
1435<dd> <b>Side Effects</b> None
1436<p>
1437
1438<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_EnableGarbageCollection">Cudd_EnableGarbageCollection</a>
1439<a href="cuddAllDet.html#Cudd_DisableGarbageCollection">Cudd_DisableGarbageCollection</a>
1440</code>
1441
1442<dt><pre>
1443int <i></i>
1444<a name="Cudd_GenFree"><b>Cudd_GenFree</b></a>(
1445  DdGen * <b>gen</b> <i></i>
1446)
1447</pre>
1448<dd> Frees a CUDD generator. Always returns 0, so that it can be used in mis-like foreach constructs.
1449<p>
1450
1451<dd> <b>Side Effects</b> None
1452<p>
1453
1454<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_ForeachCube">Cudd_ForeachCube</a>
1455<a href="cuddAllDet.html#Cudd_ForeachNode">Cudd_ForeachNode</a>
1456<a href="cuddAllDet.html#Cudd_FirstCube">Cudd_FirstCube</a>
1457<a href="cuddAllDet.html#Cudd_NextCube">Cudd_NextCube</a>
1458<a href="cuddAllDet.html#Cudd_FirstNode">Cudd_FirstNode</a>
1459<a href="cuddAllDet.html#Cudd_NextNode">Cudd_NextNode</a>
1460<a href="cuddAllDet.html#Cudd_IsGenEmpty">Cudd_IsGenEmpty</a>
1461</code>
1462
1463<dt><pre>
1464DdNode * <i></i>
1465<a name="Cudd_Increasing"><b>Cudd_Increasing</b></a>(
1466  DdManager * <b>dd</b>, <i></i>
1467  DdNode * <b>f</b>, <i></i>
1468  int  <b>i</b> <i></i>
1469)
1470</pre>
1471<dd> Determines whether the function represented by BDD f is positive unate (monotonic increasing) in variable i. It is based on Cudd_Decreasing and the fact that f is monotonic increasing in i if and only if its complement is monotonic decreasing in i.
1472<p>
1473
1474<dd> <b>Side Effects</b> None
1475<p>
1476
1477<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_Decreasing">Cudd_Decreasing</a>
1478</code>
1479
1480<dt><pre>
1481DdNode * <i></i>
1482<a name="Cudd_IndicesToCube"><b>Cudd_IndicesToCube</b></a>(
1483  DdManager * <b>dd</b>, <i></i>
1484  int * <b>array</b>, <i></i>
1485  int  <b>n</b> <i></i>
1486)
1487</pre>
1488<dd> Builds a cube of BDD variables from an array of indices. Returns a pointer to the result if successful; NULL otherwise.
1489<p>
1490
1491<dd> <b>Side Effects</b> None
1492<p>
1493
1494<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_bddComputeCube">Cudd_bddComputeCube</a>
1495<a href="cuddAllDet.html#Cudd_CubeArrayToBdd">Cudd_CubeArrayToBdd</a>
1496</code>
1497
1498<dt><pre>
1499DdManager * <i></i>
1500<a name="Cudd_Init"><b>Cudd_Init</b></a>(
1501  unsigned int  <b>numVars</b>, <i>initial number of BDD variables (i.e., subtables)</i>
1502  unsigned int  <b>numVarsZ</b>, <i>initial number of ZDD variables (i.e., subtables)</i>
1503  unsigned int  <b>numSlots</b>, <i>initial size of the unique tables</i>
1504  unsigned int  <b>cacheSize</b>, <i>initial size of the cache</i>
1505  unsigned long  <b>maxMemory</b> <i>target maximum memory occupation</i>
1506)
1507</pre>
1508<dd> Creates a new DD manager, initializes the table, the basic constants and the projection functions. If maxMemory is 0, Cudd_Init decides suitable values for the maximum size of the cache and for the limit for fast unique table growth based on the available memory. Returns a pointer to the manager if successful; NULL otherwise.
1509<p>
1510
1511<dd> <b>Side Effects</b> None
1512<p>
1513
1514<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_Quit">Cudd_Quit</a>
1515</code>
1516
1517<dt><pre>
1518 <i></i>
1519<a name="Cudd_IsComplement"><b>Cudd_IsComplement</b></a>(
1520   <b>node</b> <i></i>
1521)
1522</pre>
1523<dd> Returns 1 if a pointer is complemented.
1524<p>
1525
1526<dd> <b>Side Effects</b> none
1527<p>
1528
1529<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_Regular">Cudd_Regular</a>
1530<a href="cuddAllDet.html#Cudd_Complement">Cudd_Complement</a>
1531</code>
1532
1533<dt><pre>
1534 <i></i>
1535<a name="Cudd_IsConstant"><b>Cudd_IsConstant</b></a>(
1536   <b>node</b> <i></i>
1537)
1538</pre>
1539<dd> Returns 1 if the node is a constant node (rather than an internal node). All constant nodes have the same index (CUDD_CONST_INDEX). The pointer passed to Cudd_IsConstant may be either regular or complemented.
1540<p>
1541
1542<dd> <b>Side Effects</b> none
1543<p>
1544
1545<dt><pre>
1546int <i></i>
1547<a name="Cudd_IsGenEmpty"><b>Cudd_IsGenEmpty</b></a>(
1548  DdGen * <b>gen</b> <i></i>
1549)
1550</pre>
1551<dd> Queries the status of a generator. Returns 1 if the generator is empty or NULL; 0 otherswise.
1552<p>
1553
1554<dd> <b>Side Effects</b> None
1555<p>
1556
1557<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_ForeachCube">Cudd_ForeachCube</a>
1558<a href="cuddAllDet.html#Cudd_ForeachNode">Cudd_ForeachNode</a>
1559<a href="cuddAllDet.html#Cudd_FirstCube">Cudd_FirstCube</a>
1560<a href="cuddAllDet.html#Cudd_NextCube">Cudd_NextCube</a>
1561<a href="cuddAllDet.html#Cudd_FirstNode">Cudd_FirstNode</a>
1562<a href="cuddAllDet.html#Cudd_NextNode">Cudd_NextNode</a>
1563<a href="cuddAllDet.html#Cudd_GenFree">Cudd_GenFree</a>
1564</code>
1565
1566<dt><pre>
1567int <i></i>
1568<a name="Cudd_IsInHook"><b>Cudd_IsInHook</b></a>(
1569  DdManager * <b>dd</b>, <i></i>
1570  DD_HFP  <b>f</b>, <i></i>
1571  Cudd_HookType  <b>where</b> <i></i>
1572)
1573</pre>
1574<dd> Checks whether a function is in a hook. A hook is a list of application-provided functions called on certain occasions by the package. Returns 1 if the function is found; 0 otherwise.
1575<p>
1576
1577<dd> <b>Side Effects</b> None
1578<p>
1579
1580<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_AddHook">Cudd_AddHook</a>
1581<a href="cuddAllDet.html#Cudd_RemoveHook">Cudd_RemoveHook</a>
1582</code>
1583
1584<dt><pre>
1585int <i></i>
1586<a name="Cudd_IsNonConstant"><b>Cudd_IsNonConstant</b></a>(
1587  DdNode * <b>f</b> <i></i>
1588)
1589</pre>
1590<dd> Returns 1 if a DD node is not constant. 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 the macro Cudd_IsConstant can be used.
1591<p>
1592
1593<dd> <b>Side Effects</b> None
1594<p>
1595
1596<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_IsConstant">Cudd_IsConstant</a>
1597<a href="cuddAllDet.html#Cudd_bddIteConstant">Cudd_bddIteConstant</a>
1598<a href="cuddAllDet.html#Cudd_addIteConstant">Cudd_addIteConstant</a>
1599<a href="cuddAllDet.html#Cudd_addEvalConst">Cudd_addEvalConst</a>
1600</code>
1601
1602<dt><pre>
1603void <i></i>
1604<a name="Cudd_IterDerefBdd"><b>Cudd_IterDerefBdd</b></a>(
1605  DdManager * <b>table</b>, <i></i>
1606  DdNode * <b>n</b> <i></i>
1607)
1608</pre>
1609<dd> Decreases the reference count of node n. If n dies, recursively decreases the reference counts of its children. It is used to dispose of a BDD that is no longer needed. It is more efficient than Cudd_RecursiveDeref, but it cannot be used on ADDs. The greater efficiency comes from being able to assume that no constant node will ever die as a result of a call to this procedure.
1610<p>
1611
1612<dd> <b>Side Effects</b> None
1613<p>
1614
1615<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_RecursiveDeref">Cudd_RecursiveDeref</a>
1616<a href="cuddAllDet.html#Cudd_DelayedDerefBdd">Cudd_DelayedDerefBdd</a>
1617</code>
1618
1619<dt><pre>
1620DdNode * <i></i>
1621<a name="Cudd_LargestCube"><b>Cudd_LargestCube</b></a>(
1622  DdManager * <b>manager</b>, <i></i>
1623  DdNode * <b>f</b>, <i></i>
1624  int * <b>length</b> <i></i>
1625)
1626</pre>
1627<dd> Finds a largest cube in a DD. f is the DD we want to get the largest cube for. The problem is translated into the one of finding a shortest path in f, when both THEN and ELSE arcs are assumed to have unit length. This yields a largest cube in the disjoint cover corresponding to the DD. Therefore, it is not necessarily the largest implicant of f. Returns the largest cube as a BDD.
1628<p>
1629
1630<dd> <b>Side Effects</b> The number of literals of the cube is returned in length.
1631<p>
1632
1633<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_ShortestPath">Cudd_ShortestPath</a>
1634</code>
1635
1636<dt><pre>
1637DdNode  * <i></i>
1638<a name="Cudd_MakeBddFromZddCover"><b>Cudd_MakeBddFromZddCover</b></a>(
1639  DdManager * <b>dd</b>, <i></i>
1640  DdNode * <b>node</b> <i></i>
1641)
1642</pre>
1643<dd> Converts a ZDD cover to a BDD graph. If successful, it returns a BDD node, otherwise it returns NULL.
1644<p>
1645
1646<dd> <b>See Also</b> <code><a href="cuddAllDet.html#cuddMakeBddFromZddCover">cuddMakeBddFromZddCover</a>
1647</code>
1648
1649<dt><pre>
1650MtrNode * <i></i>
1651<a name="Cudd_MakeTreeNode"><b>Cudd_MakeTreeNode</b></a>(
1652  DdManager * <b>dd</b>, <i>manager</i>
1653  unsigned int  <b>low</b>, <i>index of the first group variable</i>
1654  unsigned int  <b>size</b>, <i>number of variables in the group</i>
1655  unsigned int  <b>type</b> <i>MTR_DEFAULT or MTR_FIXED</i>
1656)
1657</pre>
1658<dd> Creates a new variable group. The group starts at variable and contains size variables. The parameter low is the index of the first variable. If the variable already exists, its current position in the order is known to the manager. If the variable does not exist yet, the position is assumed to be the same as the index. The group tree is created if it does not exist yet. Returns a pointer to the group if successful; NULL otherwise.
1659<p>
1660
1661<dd> <b>Side Effects</b> The variable tree is changed.
1662<p>
1663
1664<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_MakeZddTreeNode">Cudd_MakeZddTreeNode</a>
1665</code>
1666
1667<dt><pre>
1668MtrNode * <i></i>
1669<a name="Cudd_MakeZddTreeNode"><b>Cudd_MakeZddTreeNode</b></a>(
1670  DdManager * <b>dd</b>, <i>manager</i>
1671  unsigned int  <b>low</b>, <i>index of the first group variable</i>
1672  unsigned int  <b>size</b>, <i>number of variables in the group</i>
1673  unsigned int  <b>type</b> <i>MTR_DEFAULT or MTR_FIXED</i>
1674)
1675</pre>
1676<dd> Creates a new ZDD variable group. The group starts at variable and contains size variables. The parameter low is the index of the first variable. If the variable already exists, its current position in the order is known to the manager. If the variable does not exist yet, the position is assumed to be the same as the index. The group tree is created if it does not exist yet. Returns a pointer to the group if successful; NULL otherwise.
1677<p>
1678
1679<dd> <b>Side Effects</b> The ZDD variable tree is changed.
1680<p>
1681
1682<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_MakeTreeNode">Cudd_MakeTreeNode</a>
1683</code>
1684
1685<dt><pre>
1686int <i></i>
1687<a name="Cudd_MinHammingDist"><b>Cudd_MinHammingDist</b></a>(
1688  DdManager * <b>dd</b>, <i>DD manager</i>
1689  DdNode * <b>f</b>, <i>function to examine</i>
1690  int * <b>minterm</b>, <i>reference minterm</i>
1691  int  <b>upperBound</b> <i>distance above which an approximate answer is OK</i>
1692)
1693</pre>
1694<dd> Returns the minimum Hamming distance between the minterms of a function f and a reference minterm. The function is given as a BDD; the minterm is given as an array of integers, one for each variable in the manager. Returns the minimum distance if it is less than the upper bound; the upper bound if the minimum distance is at least as large; CUDD_OUT_OF_MEM in case of failure.
1695<p>
1696
1697<dd> <b>Side Effects</b> None
1698<p>
1699
1700<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_addHamming">Cudd_addHamming</a>
1701<a href="cuddAllDet.html#Cudd_bddClosestCube">Cudd_bddClosestCube</a>
1702</code>
1703
1704<dt><pre>
1705DdApaNumber <i></i>
1706<a name="Cudd_NewApaNumber"><b>Cudd_NewApaNumber</b></a>(
1707  int  <b>digits</b> <i></i>
1708)
1709</pre>
1710<dd> Allocates memory for an arbitrary precision integer. Returns a pointer to the allocated memory if successful; NULL otherwise.
1711<p>
1712
1713<dd> <b>Side Effects</b> None
1714<p>
1715
1716<dt><pre>
1717int <i></i>
1718<a name="Cudd_NextCube"><b>Cudd_NextCube</b></a>(
1719  DdGen * <b>gen</b>, <i></i>
1720  int ** <b>cube</b>, <i></i>
1721  CUDD_VALUE_TYPE * <b>value</b> <i></i>
1722)
1723</pre>
1724<dd> Generates the next cube of a decision diagram onset, using generator gen. Returns 0 if the enumeration is completed; 1 otherwise.
1725<p>
1726
1727<dd> <b>Side Effects</b> The cube and its value are returned as side effects. The generator is modified.
1728<p>
1729
1730<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_ForeachCube">Cudd_ForeachCube</a>
1731<a href="cuddAllDet.html#Cudd_FirstCube">Cudd_FirstCube</a>
1732<a href="cuddAllDet.html#Cudd_GenFree">Cudd_GenFree</a>
1733<a href="cuddAllDet.html#Cudd_IsGenEmpty">Cudd_IsGenEmpty</a>
1734<a href="cuddAllDet.html#Cudd_NextNode">Cudd_NextNode</a>
1735</code>
1736
1737<dt><pre>
1738int <i></i>
1739<a name="Cudd_NextNode"><b>Cudd_NextNode</b></a>(
1740  DdGen * <b>gen</b>, <i></i>
1741  DdNode ** <b>node</b> <i></i>
1742)
1743</pre>
1744<dd> Finds the node of a decision diagram, using generator gen. Returns 0 if the enumeration is completed; 1 otherwise.
1745<p>
1746
1747<dd> <b>Side Effects</b> The next node is returned as a side effect.
1748<p>
1749
1750<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_ForeachNode">Cudd_ForeachNode</a>
1751<a href="cuddAllDet.html#Cudd_FirstNode">Cudd_FirstNode</a>
1752<a href="cuddAllDet.html#Cudd_GenFree">Cudd_GenFree</a>
1753<a href="cuddAllDet.html#Cudd_IsGenEmpty">Cudd_IsGenEmpty</a>
1754<a href="cuddAllDet.html#Cudd_NextCube">Cudd_NextCube</a>
1755</code>
1756
1757<dt><pre>
1758int <i></i>
1759<a name="Cudd_NextPrime"><b>Cudd_NextPrime</b></a>(
1760  DdGen * <b>gen</b>, <i></i>
1761  int ** <b>cube</b> <i></i>
1762)
1763</pre>
1764<dd> Generates the next cube of a Boolean function, using generator gen. Returns 0 if the enumeration is completed; 1 otherwise.
1765<p>
1766
1767<dd> <b>Side Effects</b> The cube and is returned as side effects. The generator is modified.
1768<p>
1769
1770<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_ForeachPrime">Cudd_ForeachPrime</a>
1771<a href="cuddAllDet.html#Cudd_FirstPrime">Cudd_FirstPrime</a>
1772<a href="cuddAllDet.html#Cudd_GenFree">Cudd_GenFree</a>
1773<a href="cuddAllDet.html#Cudd_IsGenEmpty">Cudd_IsGenEmpty</a>
1774<a href="cuddAllDet.html#Cudd_NextCube">Cudd_NextCube</a>
1775<a href="cuddAllDet.html#Cudd_NextNode">Cudd_NextNode</a>
1776</code>
1777
1778<dt><pre>
1779unsigned int <i></i>
1780<a name="Cudd_NodeReadIndex"><b>Cudd_NodeReadIndex</b></a>(
1781  DdNode * <b>node</b> <i></i>
1782)
1783</pre>
1784<dd> Returns the index of the node. The node pointer can be either regular or complemented.
1785<p>
1786
1787<dd> <b>Side Effects</b> None
1788<p>
1789
1790<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_ReadIndex">Cudd_ReadIndex</a>
1791</code>
1792
1793<dt><pre>
1794 <i></i>
1795<a name="Cudd_NotCond"><b>Cudd_NotCond</b></a>(
1796   <b>node</b>, <i></i>
1797   <b>c</b> <i></i>
1798)
1799</pre>
1800<dd> Complements a DD if condition c is true; c should be either 0 or 1, because it is used directly (for efficiency). If in doubt on the values c may take, use "(c) ? Cudd_Not(node) : node".
1801<p>
1802
1803<dd> <b>Side Effects</b> none
1804<p>
1805
1806<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_Not">Cudd_Not</a>
1807</code>
1808
1809<dt><pre>
1810 <i></i>
1811<a name="Cudd_Not"><b>Cudd_Not</b></a>(
1812   <b>node</b> <i></i>
1813)
1814</pre>
1815<dd> Complements a DD by flipping the complement attribute of the pointer (the least significant bit).
1816<p>
1817
1818<dd> <b>Side Effects</b> none
1819<p>
1820
1821<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_NotCond">Cudd_NotCond</a>
1822</code>
1823
1824<dt><pre>
1825void <i></i>
1826<a name="Cudd_OutOfMem"><b>Cudd_OutOfMem</b></a>(
1827  long  <b>size</b> <i>size of the allocation that failed</i>
1828)
1829</pre>
1830<dd> Warns that a memory allocation failed. This function can be used as replacement of MMout_of_memory to prevent the safe_mem functions of the util package from exiting when malloc returns NULL. One possible use is in case of discretionary allocations; for instance, the allocation of memory to enlarge the computed table.
1831<p>
1832
1833<dd> <b>Side Effects</b> None
1834<p>
1835
1836<dt><pre>
1837DdNode * <i></i>
1838<a name="Cudd_OverApprox"><b>Cudd_OverApprox</b></a>(
1839  DdManager * <b>dd</b>, <i>manager</i>
1840  DdNode * <b>f</b>, <i>function to be superset</i>
1841  int  <b>numVars</b>, <i>number of variables in the support of f</i>
1842  int  <b>threshold</b>, <i>when to stop approximation</i>
1843  int  <b>safe</b>, <i>enforce safe approximation</i>
1844  double  <b>quality</b> <i>minimum improvement for accepted changes</i>
1845)
1846</pre>
1847<dd> Extracts a dense superset from a BDD. The procedure is identical to the underapproximation procedure except for the fact that it works on the complement of the given function. Extracting the subset of the complement function is equivalent to extracting the superset of the function. Returns a pointer to the BDD of the superset if successful. NULL if intermediate result causes the procedure to run out of memory. The parameter numVars is the maximum number of variables to be used in minterm calculation. The optimal number should be as close as possible to the size of the support of f. However, it is safe to pass the value returned by Cudd_ReadSize for numVars when the number of variables is under 1023. If numVars is larger than 1023, it will overflow. If a 0 parameter is passed then the procedure will compute a value which will avoid overflow but will cause underflow with 2046 variables or more.
1848<p>
1849
1850<dd> <b>Side Effects</b> None
1851<p>
1852
1853<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_SupersetHeavyBranch">Cudd_SupersetHeavyBranch</a>
1854<a href="cuddAllDet.html#Cudd_SupersetShortPaths">Cudd_SupersetShortPaths</a>
1855<a href="cuddAllDet.html#Cudd_ReadSize">Cudd_ReadSize</a>
1856</code>
1857
1858<dt><pre>
1859unsigned int <i></i>
1860<a name="Cudd_Prime"><b>Cudd_Prime</b></a>(
1861  unsigned int  <b>p</b> <i></i>
1862)
1863</pre>
1864<dd> Returns the next prime &gt;= p.
1865<p>
1866
1867<dd> <b>Side Effects</b> None
1868<p>
1869
1870<dt><pre>
1871int <i></i>
1872<a name="Cudd_PrintDebug"><b>Cudd_PrintDebug</b></a>(
1873  DdManager * <b>dd</b>, <i></i>
1874  DdNode * <b>f</b>, <i></i>
1875  int  <b>n</b>, <i></i>
1876  int  <b>pr</b> <i></i>
1877)
1878</pre>
1879<dd> Prints to the standard output a DD and its statistics. The statistics include the number of nodes, the number of leaves, and the number of minterms. (The number of minterms is the number of assignments to the variables that cause the function to be different from the logical zero (for BDDs) and from the background value (for ADDs.) The statistics are printed if pr &gt; 0. Specifically: <ul> <li> pr = 0 : prints nothing <li> pr = 1 : prints counts of nodes and minterms <li> pr = 2 : prints counts + disjoint sum of product <li> pr = 3 : prints counts + list of nodes <li> pr &gt; 3 : prints counts + disjoint sum of product + list of nodes </ul> For the purpose of counting the number of minterms, the function is supposed to depend on n variables. Returns 1 if successful; 0 otherwise.
1880<p>
1881
1882<dd> <b>Side Effects</b> None
1883<p>
1884
1885<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_DagSize">Cudd_DagSize</a>
1886<a href="cuddAllDet.html#Cudd_CountLeaves">Cudd_CountLeaves</a>
1887<a href="cuddAllDet.html#Cudd_CountMinterm">Cudd_CountMinterm</a>
1888<a href="cuddAllDet.html#Cudd_PrintMinterm">Cudd_PrintMinterm</a>
1889</code>
1890
1891<dt><pre>
1892int <i></i>
1893<a name="Cudd_PrintInfo"><b>Cudd_PrintInfo</b></a>(
1894  DdManager * <b>dd</b>, <i></i>
1895  FILE * <b>fp</b> <i></i>
1896)
1897</pre>
1898<dd> Prints out statistics and settings for a CUDD manager. Returns 1 if successful; 0 otherwise.
1899<p>
1900
1901<dd> <b>Side Effects</b> None
1902<p>
1903
1904<dt><pre>
1905int <i></i>
1906<a name="Cudd_PrintLinear"><b>Cudd_PrintLinear</b></a>(
1907  DdManager * <b>table</b> <i></i>
1908)
1909</pre>
1910<dd> Prints the linear transform matrix. Returns 1 in case of success; 0 otherwise.
1911<p>
1912
1913<dd> <b>Side Effects</b> none
1914<p>
1915
1916<dt><pre>
1917int <i></i>
1918<a name="Cudd_PrintMinterm"><b>Cudd_PrintMinterm</b></a>(
1919  DdManager * <b>manager</b>, <i></i>
1920  DdNode * <b>node</b> <i></i>
1921)
1922</pre>
1923<dd> Prints a disjoint sum of product cover for the function rooted at node. Each product corresponds to a path from node to a leaf node different from the logical zero, and different from the background value. Uses the package default output file. Returns 1 if successful; 0 otherwise.
1924<p>
1925
1926<dd> <b>Side Effects</b> None
1927<p>
1928
1929<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_PrintDebug">Cudd_PrintDebug</a>
1930<a href="cuddAllDet.html#Cudd_bddPrintCover">Cudd_bddPrintCover</a>
1931</code>
1932
1933<dt><pre>
1934int <i></i>
1935<a name="Cudd_PrintTwoLiteralClauses"><b>Cudd_PrintTwoLiteralClauses</b></a>(
1936  DdManager * <b>dd</b>, <i></i>
1937  DdNode * <b>f</b>, <i></i>
1938  char ** <b>names</b>, <i></i>
1939  FILE * <b>fp</b> <i></i>
1940)
1941</pre>
1942<dd> Prints the one- and two-literal clauses. Returns 1 if successful; 0 otherwise. The argument "names" can be NULL, in which case the variable indices are printed.
1943<p>
1944
1945<dd> <b>Side Effects</b> None
1946<p>
1947
1948<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_FindTwoLiteralClauses">Cudd_FindTwoLiteralClauses</a>
1949</code>
1950
1951<dt><pre>
1952void <i></i>
1953<a name="Cudd_PrintVersion"><b>Cudd_PrintVersion</b></a>(
1954  FILE * <b>fp</b> <i></i>
1955)
1956</pre>
1957<dd> Prints the package version number.
1958<p>
1959
1960<dd> <b>Side Effects</b> None
1961<p>
1962
1963<dt><pre>
1964DdNode * <i></i>
1965<a name="Cudd_PrioritySelect"><b>Cudd_PrioritySelect</b></a>(
1966  DdManager * <b>dd</b>, <i>manager</i>
1967  DdNode * <b>R</b>, <i>BDD of the relation</i>
1968  DdNode ** <b>x</b>, <i>array of x variables</i>
1969  DdNode ** <b>y</b>, <i>array of y variables</i>
1970  DdNode ** <b>z</b>, <i>array of z variables (optional: may be NULL)</i>
1971  DdNode * <b>Pi</b>, <i>BDD of the priority function (optional: may be NULL)</i>
1972  int  <b>n</b>, <i>size of x, y, and z</i>
1973  DD_PRFP  <b>Pifunc</b> <i>function used to build Pi if it is NULL</i>
1974)
1975</pre>
1976<dd> Selects pairs from a relation R(x,y) (given as a BDD) in such a way that a given x appears in one pair only. Uses a priority function to determine which y should be paired to a given x. Cudd_PrioritySelect returns a pointer to the selected function if successful; NULL otherwise. Three of the arguments--x, y, and z--are vectors of BDD variables. The first two are the variables on which R depends. The third vectore is a vector of auxiliary variables, used during the computation. This vector is optional. If a NULL value is passed instead, Cudd_PrioritySelect will create the working variables on the fly. The sizes of x and y (and z if it is not NULL) should equal n. The priority function Pi can be passed as a BDD, or can be built by Cudd_PrioritySelect. If NULL is passed instead of a DdNode *, parameter Pifunc is used by Cudd_PrioritySelect to build a BDD for the priority function. (Pifunc is a pointer to a C function.) If Pi is not NULL, then Pifunc is ignored. Pifunc should have the same interface as the standard priority functions (e.g., Cudd_Dxygtdxz). Cudd_PrioritySelect and Cudd_CProjection can sometimes be used interchangeably. Specifically, calling Cudd_PrioritySelect with Cudd_Xgty as Pifunc produces the same result as calling Cudd_CProjection with the all-zero minterm as reference minterm. However, depending on the application, one or the other may be preferable: <ul> <li> When extracting representatives from an equivalence relation, Cudd_CProjection has the advantage of nor requiring the auxiliary variables. <li> When computing matchings in general bipartite graphs, Cudd_PrioritySelect normally obtains better results because it can use more powerful matching schemes (e.g., Cudd_Dxygtdxz). </ul>
1977<p>
1978
1979<dd> <b>Side Effects</b> If called with z == NULL, will create new variables in the manager.
1980<p>
1981
1982<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_Dxygtdxz">Cudd_Dxygtdxz</a>
1983<a href="cuddAllDet.html#Cudd_Dxygtdyz">Cudd_Dxygtdyz</a>
1984<a href="cuddAllDet.html#Cudd_Xgty">Cudd_Xgty</a>
1985<a href="cuddAllDet.html#Cudd_bddAdjPermuteX">Cudd_bddAdjPermuteX</a>
1986<a href="cuddAllDet.html#Cudd_CProjection">Cudd_CProjection</a>
1987</code>
1988
1989<dt><pre>
1990void <i></i>
1991<a name="Cudd_Quit"><b>Cudd_Quit</b></a>(
1992  DdManager * <b>unique</b> <i></i>
1993)
1994</pre>
1995<dd> Deletes resources associated with a DD manager and resets the global statistical counters. (Otherwise, another manaqger subsequently created would inherit the stats of this one.)
1996<p>
1997
1998<dd> <b>Side Effects</b> None
1999<p>
2000
2001<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_Init">Cudd_Init</a>
2002</code>
2003
2004<dt><pre>
2005long <i></i>
2006<a name="Cudd_Random"><b>Cudd_Random</b></a>(
2007   <b></b> <i></i>
2008)
2009</pre>
2010<dd> Portable number generator based on ran2 from "Numerical Recipes in C." It is a long period (> 2 * 10^18) random number generator of L'Ecuyer with Bays-Durham shuffle. Returns a long integer uniformly distributed between 0 and 2147483561 (inclusive of the endpoint values). The random generator can be explicitly initialized by calling Cudd_Srandom. If no explicit initialization is performed, then the seed 1 is assumed.
2011<p>
2012
2013<dd> <b>Side Effects</b> None
2014<p>
2015
2016<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_Srandom">Cudd_Srandom</a>
2017</code>
2018
2019<dt><pre>
2020int <i></i>
2021<a name="Cudd_ReadArcviolation"><b>Cudd_ReadArcviolation</b></a>(
2022  DdManager * <b>dd</b> <i></i>
2023)
2024</pre>
2025<dd> Returns the current value of the arcviolation parameter. This parameter is used in group sifting 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.
2026<p>
2027
2028<dd> <b>Side Effects</b> None
2029<p>
2030
2031<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_SetArcviolation">Cudd_SetArcviolation</a>
2032</code>
2033
2034<dt><pre>
2035DdNode * <i></i>
2036<a name="Cudd_ReadBackground"><b>Cudd_ReadBackground</b></a>(
2037  DdManager * <b>dd</b> <i></i>
2038)
2039</pre>
2040<dd> Reads the background constant of the manager.
2041<p>
2042
2043<dd> <b>Side Effects</b> None
2044<p>
2045
2046<dt><pre>
2047double <i></i>
2048<a name="Cudd_ReadCacheHits"><b>Cudd_ReadCacheHits</b></a>(
2049  DdManager * <b>dd</b> <i></i>
2050)
2051</pre>
2052<dd> Returns the number of cache hits.
2053<p>
2054
2055<dd> <b>Side Effects</b> None
2056<p>
2057
2058<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_ReadCacheLookUps">Cudd_ReadCacheLookUps</a>
2059</code>
2060
2061<dt><pre>
2062double <i></i>
2063<a name="Cudd_ReadCacheLookUps"><b>Cudd_ReadCacheLookUps</b></a>(
2064  DdManager * <b>dd</b> <i></i>
2065)
2066</pre>
2067<dd> Returns the number of cache look-ups.
2068<p>
2069
2070<dd> <b>Side Effects</b> None
2071<p>
2072
2073<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_ReadCacheHits">Cudd_ReadCacheHits</a>
2074</code>
2075
2076<dt><pre>
2077unsigned int <i></i>
2078<a name="Cudd_ReadCacheSlots"><b>Cudd_ReadCacheSlots</b></a>(
2079  DdManager * <b>dd</b> <i></i>
2080)
2081</pre>
2082<dd> Reads the number of slots in the cache.
2083<p>
2084
2085<dd> <b>Side Effects</b> None
2086<p>
2087
2088<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_ReadCacheUsedSlots">Cudd_ReadCacheUsedSlots</a>
2089</code>
2090
2091<dt><pre>
2092double <i></i>
2093<a name="Cudd_ReadCacheUsedSlots"><b>Cudd_ReadCacheUsedSlots</b></a>(
2094  DdManager * <b>dd</b> <i></i>
2095)
2096</pre>
2097<dd> Reads the fraction of used slots in the cache. 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.
2098<p>
2099
2100<dd> <b>Side Effects</b> None
2101<p>
2102
2103<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_ReadCacheSlots">Cudd_ReadCacheSlots</a>
2104</code>
2105
2106<dt><pre>
2107unsigned int <i></i>
2108<a name="Cudd_ReadDead"><b>Cudd_ReadDead</b></a>(
2109  DdManager * <b>dd</b> <i></i>
2110)
2111</pre>
2112<dd> Returns the number of dead nodes in the unique table.
2113<p>
2114
2115<dd> <b>Side Effects</b> None
2116<p>
2117
2118<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_ReadKeys">Cudd_ReadKeys</a>
2119</code>
2120
2121<dt><pre>
2122CUDD_VALUE_TYPE <i></i>
2123<a name="Cudd_ReadEpsilon"><b>Cudd_ReadEpsilon</b></a>(
2124  DdManager * <b>dd</b> <i></i>
2125)
2126</pre>
2127<dd> Reads the epsilon parameter of the manager. The epsilon parameter control the comparison between floating point numbers.
2128<p>
2129
2130<dd> <b>Side Effects</b> None
2131<p>
2132
2133<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_SetEpsilon">Cudd_SetEpsilon</a>
2134</code>
2135
2136<dt><pre>
2137Cudd_ErrorType <i></i>
2138<a name="Cudd_ReadErrorCode"><b>Cudd_ReadErrorCode</b></a>(
2139  DdManager * <b>dd</b> <i></i>
2140)
2141</pre>
2142<dd> Returns the code of the last error. The error codes are defined in cudd.h.
2143<p>
2144
2145<dd> <b>Side Effects</b> None
2146<p>
2147
2148<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_ClearErrorCode">Cudd_ClearErrorCode</a>
2149</code>
2150
2151<dt><pre>
2152long <i></i>
2153<a name="Cudd_ReadGarbageCollectionTime"><b>Cudd_ReadGarbageCollectionTime</b></a>(
2154  DdManager * <b>dd</b> <i></i>
2155)
2156</pre>
2157<dd> Returns the number of milliseconds spent doing garbage collection since the manager was initialized.
2158<p>
2159
2160<dd> <b>Side Effects</b> None
2161<p>
2162
2163<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_ReadGarbageCollections">Cudd_ReadGarbageCollections</a>
2164</code>
2165
2166<dt><pre>
2167int <i></i>
2168<a name="Cudd_ReadGarbageCollections"><b>Cudd_ReadGarbageCollections</b></a>(
2169  DdManager * <b>dd</b> <i></i>
2170)
2171</pre>
2172<dd> Returns the number of times garbage collection has occurred in the manager. The number includes both the calls from reordering procedures and those caused by requests to create new nodes.
2173<p>
2174
2175<dd> <b>Side Effects</b> None
2176<p>
2177
2178<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_ReadGarbageCollectionTime">Cudd_ReadGarbageCollectionTime</a>
2179</code>
2180
2181<dt><pre>
2182Cudd_AggregationType <i></i>
2183<a name="Cudd_ReadGroupcheck"><b>Cudd_ReadGroupcheck</b></a>(
2184  DdManager * <b>dd</b> <i></i>
2185)
2186</pre>
2187<dd> Reads the groupcheck parameter of the manager. The groupcheck parameter determines the aggregation criterion in group sifting.
2188<p>
2189
2190<dd> <b>Side Effects</b> None
2191<p>
2192
2193<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_SetGroupcheck">Cudd_SetGroupcheck</a>
2194</code>
2195
2196<dt><pre>
2197 <i></i>
2198<a name="Cudd_ReadIndex"><b>Cudd_ReadIndex</b></a>(
2199   <b>dd</b>, <i></i>
2200   <b>index</b> <i></i>
2201)
2202</pre>
2203<dd> Returns the current position in the order of variable index. This macro is obsolete and is kept for compatibility. New applications should use Cudd_ReadPerm instead.
2204<p>
2205
2206<dd> <b>Side Effects</b> none
2207<p>
2208
2209<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_ReadPerm">Cudd_ReadPerm</a>
2210</code>
2211
2212<dt><pre>
2213int <i></i>
2214<a name="Cudd_ReadInvPermZdd"><b>Cudd_ReadInvPermZdd</b></a>(
2215  DdManager * <b>dd</b>, <i></i>
2216  int  <b>i</b> <i></i>
2217)
2218</pre>
2219<dd> Returns the index of the ZDD variable currently in the i-th position of the order. If the index is CUDD_CONST_INDEX, returns CUDD_CONST_INDEX; otherwise, if the index is out of bounds returns -1.
2220<p>
2221
2222<dd> <b>Side Effects</b> None
2223<p>
2224
2225<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_ReadPerm">Cudd_ReadPerm</a>
2226<a href="cuddAllDet.html#Cudd_ReadInvPermZdd">Cudd_ReadInvPermZdd</a>
2227</code>
2228
2229<dt><pre>
2230int <i></i>
2231<a name="Cudd_ReadInvPerm"><b>Cudd_ReadInvPerm</b></a>(
2232  DdManager * <b>dd</b>, <i></i>
2233  int  <b>i</b> <i></i>
2234)
2235</pre>
2236<dd> Returns the index of the variable currently in the i-th position of the order. If the index is CUDD_CONST_INDEX, returns CUDD_CONST_INDEX; otherwise, if the index is out of bounds returns -1.
2237<p>
2238
2239<dd> <b>Side Effects</b> None
2240<p>
2241
2242<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_ReadPerm">Cudd_ReadPerm</a>
2243<a href="cuddAllDet.html#Cudd_ReadInvPermZdd">Cudd_ReadInvPermZdd</a>
2244</code>
2245
2246<dt><pre>
2247int <i></i>
2248<a name="Cudd_ReadIthClause"><b>Cudd_ReadIthClause</b></a>(
2249  DdTlcInfo * <b>tlc</b>, <i></i>
2250  int  <b>i</b>, <i></i>
2251  DdHalfWord * <b>var1</b>, <i></i>
2252  DdHalfWord * <b>var2</b>, <i></i>
2253  int * <b>phase1</b>, <i></i>
2254  int * <b>phase2</b> <i></i>
2255)
2256</pre>
2257<dd> Accesses the i-th clause of a DD given the clause set which must be already computed. Returns 1 if successful; 0 if i is out of range, or in case of error.
2258<p>
2259
2260<dd> <b>Side Effects</b> the four components of a clause are returned as side effects.
2261<p>
2262
2263<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_FindTwoLiteralClauses">Cudd_FindTwoLiteralClauses</a>
2264</code>
2265
2266<dt><pre>
2267unsigned int <i></i>
2268<a name="Cudd_ReadKeys"><b>Cudd_ReadKeys</b></a>(
2269  DdManager * <b>dd</b> <i></i>
2270)
2271</pre>
2272<dd> Returns the total number of nodes currently in the unique table, including the dead nodes.
2273<p>
2274
2275<dd> <b>Side Effects</b> None
2276<p>
2277
2278<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_ReadDead">Cudd_ReadDead</a>
2279</code>
2280
2281<dt><pre>
2282int <i></i>
2283<a name="Cudd_ReadLinear"><b>Cudd_ReadLinear</b></a>(
2284  DdManager * <b>table</b>, <i>CUDD manager</i>
2285  int  <b>x</b>, <i>row index</i>
2286  int  <b>y</b> <i>column index</i>
2287)
2288</pre>
2289<dd> Reads an entry of the linear transform matrix.
2290<p>
2291
2292<dd> <b>Side Effects</b> none
2293<p>
2294
2295<dt><pre>
2296DdNode * <i></i>
2297<a name="Cudd_ReadLogicZero"><b>Cudd_ReadLogicZero</b></a>(
2298  DdManager * <b>dd</b> <i></i>
2299)
2300</pre>
2301<dd> Returns the zero constant of the manager. The logic zero constant is the complement of the one constant, and is distinct from the arithmetic zero.
2302<p>
2303
2304<dd> <b>Side Effects</b> None
2305<p>
2306
2307<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_ReadOne">Cudd_ReadOne</a>
2308<a href="cuddAllDet.html#Cudd_ReadZero">Cudd_ReadZero</a>
2309</code>
2310
2311<dt><pre>
2312unsigned int <i></i>
2313<a name="Cudd_ReadLooseUpTo"><b>Cudd_ReadLooseUpTo</b></a>(
2314  DdManager * <b>dd</b> <i></i>
2315)
2316</pre>
2317<dd> Reads the looseUpTo parameter of the manager.
2318<p>
2319
2320<dd> <b>Side Effects</b> None
2321<p>
2322
2323<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_SetLooseUpTo">Cudd_SetLooseUpTo</a>
2324<a href="cuddAllDet.html#Cudd_ReadMinHit">Cudd_ReadMinHit</a>
2325<a href="cuddAllDet.html#Cudd_ReadMinDead">Cudd_ReadMinDead</a>
2326</code>
2327
2328<dt><pre>
2329unsigned int <i></i>
2330<a name="Cudd_ReadMaxCacheHard"><b>Cudd_ReadMaxCacheHard</b></a>(
2331  DdManager * <b>dd</b> <i></i>
2332)
2333</pre>
2334<dd> Reads the maxCacheHard parameter of the manager.
2335<p>
2336
2337<dd> <b>Side Effects</b> None
2338<p>
2339
2340<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_SetMaxCacheHard">Cudd_SetMaxCacheHard</a>
2341<a href="cuddAllDet.html#Cudd_ReadMaxCache">Cudd_ReadMaxCache</a>
2342</code>
2343
2344<dt><pre>
2345unsigned int <i></i>
2346<a name="Cudd_ReadMaxCache"><b>Cudd_ReadMaxCache</b></a>(
2347  DdManager * <b>dd</b> <i></i>
2348)
2349</pre>
2350<dd> Returns the soft limit for the cache size. The soft limit
2351<p>
2352
2353<dd> <b>Side Effects</b> None
2354<p>
2355
2356<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_ReadMaxCache">Cudd_ReadMaxCache</a>
2357</code>
2358
2359<dt><pre>
2360double <i></i>
2361<a name="Cudd_ReadMaxGrowthAlternate"><b>Cudd_ReadMaxGrowthAlternate</b></a>(
2362  DdManager * <b>dd</b> <i></i>
2363)
2364</pre>
2365<dd> Reads the maxGrowthAlt parameter of the manager. 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.
2366<p>
2367
2368<dd> <b>Side Effects</b> None
2369<p>
2370
2371<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_ReadMaxGrowth">Cudd_ReadMaxGrowth</a>
2372<a href="cuddAllDet.html#Cudd_SetMaxGrowthAlternate">Cudd_SetMaxGrowthAlternate</a>
2373<a href="cuddAllDet.html#Cudd_SetReorderingCycle">Cudd_SetReorderingCycle</a>
2374<a href="cuddAllDet.html#Cudd_ReadReorderingCycle">Cudd_ReadReorderingCycle</a>
2375</code>
2376
2377<dt><pre>
2378double <i></i>
2379<a name="Cudd_ReadMaxGrowth"><b>Cudd_ReadMaxGrowth</b></a>(
2380  DdManager * <b>dd</b> <i></i>
2381)
2382</pre>
2383<dd> Reads the maxGrowth parameter of the manager. 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.
2384<p>
2385
2386<dd> <b>Side Effects</b> None
2387<p>
2388
2389<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_SetMaxGrowth">Cudd_SetMaxGrowth</a>
2390<a href="cuddAllDet.html#Cudd_ReadMaxGrowthAlternate">Cudd_ReadMaxGrowthAlternate</a>
2391</code>
2392
2393<dt><pre>
2394unsigned int <i></i>
2395<a name="Cudd_ReadMaxLive"><b>Cudd_ReadMaxLive</b></a>(
2396  DdManager * <b>dd</b> <i></i>
2397)
2398</pre>
2399<dd> Reads the maximum allowed number of live nodes. When this number is exceeded, the package returns NULL.
2400<p>
2401
2402<dd> <b>Side Effects</b> none
2403<p>
2404
2405<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_SetMaxLive">Cudd_SetMaxLive</a>
2406</code>
2407
2408<dt><pre>
2409unsigned long <i></i>
2410<a name="Cudd_ReadMaxMemory"><b>Cudd_ReadMaxMemory</b></a>(
2411  DdManager * <b>dd</b> <i></i>
2412)
2413</pre>
2414<dd> Reads the maximum allowed memory. When this number is exceeded, the package returns NULL.
2415<p>
2416
2417<dd> <b>Side Effects</b> none
2418<p>
2419
2420<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_SetMaxMemory">Cudd_SetMaxMemory</a>
2421</code>
2422
2423<dt><pre>
2424unsigned long <i></i>
2425<a name="Cudd_ReadMemoryInUse"><b>Cudd_ReadMemoryInUse</b></a>(
2426  DdManager * <b>dd</b> <i></i>
2427)
2428</pre>
2429<dd> Returns the memory in use by the manager measured in bytes.
2430<p>
2431
2432<dd> <b>Side Effects</b> None
2433<p>
2434
2435<dt><pre>
2436unsigned int <i></i>
2437<a name="Cudd_ReadMinDead"><b>Cudd_ReadMinDead</b></a>(
2438  DdManager * <b>dd</b> <i></i>
2439)
2440</pre>
2441<dd> Reads the minDead parameter of the manager. 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.
2442<p>
2443
2444<dd> <b>Side Effects</b> None
2445<p>
2446
2447<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_ReadDead">Cudd_ReadDead</a>
2448<a href="cuddAllDet.html#Cudd_ReadLooseUpTo">Cudd_ReadLooseUpTo</a>
2449<a href="cuddAllDet.html#Cudd_SetLooseUpTo">Cudd_SetLooseUpTo</a>
2450</code>
2451
2452<dt><pre>
2453unsigned int <i></i>
2454<a name="Cudd_ReadMinHit"><b>Cudd_ReadMinHit</b></a>(
2455  DdManager * <b>dd</b> <i></i>
2456)
2457</pre>
2458<dd> Reads the hit rate that causes resizinig of the computed table.
2459<p>
2460
2461<dd> <b>Side Effects</b> None
2462<p>
2463
2464<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_SetMinHit">Cudd_SetMinHit</a>
2465</code>
2466
2467<dt><pre>
2468DdNode * <i></i>
2469<a name="Cudd_ReadMinusInfinity"><b>Cudd_ReadMinusInfinity</b></a>(
2470  DdManager * <b>dd</b> <i></i>
2471)
2472</pre>
2473<dd> Reads the minus-infinity constant from the manager.
2474<p>
2475
2476<dd> <b>Side Effects</b> None
2477<p>
2478
2479<dt><pre>
2480unsigned int <i></i>
2481<a name="Cudd_ReadNextReordering"><b>Cudd_ReadNextReordering</b></a>(
2482  DdManager * <b>dd</b> <i></i>
2483)
2484</pre>
2485<dd> Returns the threshold for the next dynamic reordering. 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.
2486<p>
2487
2488<dd> <b>Side Effects</b> None
2489<p>
2490
2491<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_SetNextReordering">Cudd_SetNextReordering</a>
2492</code>
2493
2494<dt><pre>
2495long <i></i>
2496<a name="Cudd_ReadNodeCount"><b>Cudd_ReadNodeCount</b></a>(
2497  DdManager * <b>dd</b> <i></i>
2498)
2499</pre>
2500<dd> Reports the number of live nodes in BDDs and ADDs. 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.
2501<p>
2502
2503<dd> <b>Side Effects</b> None
2504<p>
2505
2506<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_ReadPeakNodeCount">Cudd_ReadPeakNodeCount</a>
2507<a href="cuddAllDet.html#Cudd_zddReadNodeCount">Cudd_zddReadNodeCount</a>
2508</code>
2509
2510<dt><pre>
2511double <i></i>
2512<a name="Cudd_ReadNodesDropped"><b>Cudd_ReadNodesDropped</b></a>(
2513  DdManager * <b>dd</b> <i></i>
2514)
2515</pre>
2516<dd> 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.
2517<p>
2518
2519<dd> <b>Side Effects</b> None
2520<p>
2521
2522<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_ReadNodesFreed">Cudd_ReadNodesFreed</a>
2523</code>
2524
2525<dt><pre>
2526double <i></i>
2527<a name="Cudd_ReadNodesFreed"><b>Cudd_ReadNodesFreed</b></a>(
2528  DdManager * <b>dd</b> <i></i>
2529)
2530</pre>
2531<dd> 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.
2532<p>
2533
2534<dd> <b>Side Effects</b> None
2535<p>
2536
2537<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_ReadNodesDropped">Cudd_ReadNodesDropped</a>
2538</code>
2539
2540<dt><pre>
2541int <i></i>
2542<a name="Cudd_ReadNumberXovers"><b>Cudd_ReadNumberXovers</b></a>(
2543  DdManager * <b>dd</b> <i></i>
2544)
2545</pre>
2546<dd> Reads the current number of crossovers used by the genetic algorithm for variable reordering. 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.
2547<p>
2548
2549<dd> <b>Side Effects</b> None
2550<p>
2551
2552<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_SetNumberXovers">Cudd_SetNumberXovers</a>
2553</code>
2554
2555<dt><pre>
2556DdNode * <i></i>
2557<a name="Cudd_ReadOne"><b>Cudd_ReadOne</b></a>(
2558  DdManager * <b>dd</b> <i></i>
2559)
2560</pre>
2561<dd> Returns the one constant of the manager. The one constant is common to ADDs and BDDs.
2562<p>
2563
2564<dd> <b>Side Effects</b> None
2565<p>
2566
2567<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_ReadZero">Cudd_ReadZero</a>
2568<a href="cuddAllDet.html#Cudd_ReadLogicZero">Cudd_ReadLogicZero</a>
2569<a href="cuddAllDet.html#Cudd_ReadZddOne">Cudd_ReadZddOne</a>
2570</code>
2571
2572<dt><pre>
2573int <i></i>
2574<a name="Cudd_ReadPeakLiveNodeCount"><b>Cudd_ReadPeakLiveNodeCount</b></a>(
2575  DdManager * <b>dd</b> <i></i>
2576)
2577</pre>
2578<dd> Reports the peak number of live nodes. This count is kept only if CUDD is compiled with DD_STATS defined. If DD_STATS is not defined, this function returns -1.
2579<p>
2580
2581<dd> <b>Side Effects</b> None
2582<p>
2583
2584<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_ReadNodeCount">Cudd_ReadNodeCount</a>
2585<a href="cuddAllDet.html#Cudd_PrintInfo">Cudd_PrintInfo</a>
2586<a href="cuddAllDet.html#Cudd_ReadPeakNodeCount">Cudd_ReadPeakNodeCount</a>
2587</code>
2588
2589<dt><pre>
2590long <i></i>
2591<a name="Cudd_ReadPeakNodeCount"><b>Cudd_ReadPeakNodeCount</b></a>(
2592  DdManager * <b>dd</b> <i></i>
2593)
2594</pre>
2595<dd> Reports the peak number of nodes. 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.
2596<p>
2597
2598<dd> <b>Side Effects</b> None
2599<p>
2600
2601<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_ReadNodeCount">Cudd_ReadNodeCount</a>
2602<a href="cuddAllDet.html#Cudd_PrintInfo">Cudd_PrintInfo</a>
2603</code>
2604
2605<dt><pre>
2606int <i></i>
2607<a name="Cudd_ReadPermZdd"><b>Cudd_ReadPermZdd</b></a>(
2608  DdManager * <b>dd</b>, <i></i>
2609  int  <b>i</b> <i></i>
2610)
2611</pre>
2612<dd> Returns the current position of the i-th ZDD variable in the order. If the index is CUDD_CONST_INDEX, returns CUDD_CONST_INDEX; otherwise, if the index is out of bounds returns -1.
2613<p>
2614
2615<dd> <b>Side Effects</b> None
2616<p>
2617
2618<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_ReadInvPermZdd">Cudd_ReadInvPermZdd</a>
2619<a href="cuddAllDet.html#Cudd_ReadPerm">Cudd_ReadPerm</a>
2620</code>
2621
2622<dt><pre>
2623int <i></i>
2624<a name="Cudd_ReadPerm"><b>Cudd_ReadPerm</b></a>(
2625  DdManager * <b>dd</b>, <i></i>
2626  int  <b>i</b> <i></i>
2627)
2628</pre>
2629<dd> Returns the current position of the i-th variable in the order. If the index is CUDD_CONST_INDEX, returns CUDD_CONST_INDEX; otherwise, if the index is out of bounds returns -1.
2630<p>
2631
2632<dd> <b>Side Effects</b> None
2633<p>
2634
2635<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_ReadInvPerm">Cudd_ReadInvPerm</a>
2636<a href="cuddAllDet.html#Cudd_ReadPermZdd">Cudd_ReadPermZdd</a>
2637</code>
2638
2639<dt><pre>
2640DdNode * <i></i>
2641<a name="Cudd_ReadPlusInfinity"><b>Cudd_ReadPlusInfinity</b></a>(
2642  DdManager * <b>dd</b> <i></i>
2643)
2644</pre>
2645<dd> Reads the plus-infinity constant from the manager.
2646<p>
2647
2648<dd> <b>Side Effects</b> None
2649<p>
2650
2651<dt><pre>
2652int <i></i>
2653<a name="Cudd_ReadPopulationSize"><b>Cudd_ReadPopulationSize</b></a>(
2654  DdManager * <b>dd</b> <i></i>
2655)
2656</pre>
2657<dd> Reads the current size of the population used by the genetic algorithm for variable reordering. 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.
2658<p>
2659
2660<dd> <b>Side Effects</b> None
2661<p>
2662
2663<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_SetPopulationSize">Cudd_SetPopulationSize</a>
2664</code>
2665
2666<dt><pre>
2667int <i></i>
2668<a name="Cudd_ReadRecomb"><b>Cudd_ReadRecomb</b></a>(
2669  DdManager * <b>dd</b> <i></i>
2670)
2671</pre>
2672<dd> Returns the current value of the recombination parameter used in group sifting. 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.
2673<p>
2674
2675<dd> <b>Side Effects</b> None
2676<p>
2677
2678<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_SetRecomb">Cudd_SetRecomb</a>
2679</code>
2680
2681<dt><pre>
2682double <i></i>
2683<a name="Cudd_ReadRecursiveCalls"><b>Cudd_ReadRecursiveCalls</b></a>(
2684  DdManager * <b>dd</b> <i></i>
2685)
2686</pre>
2687<dd> Returns the number of recursive calls if the package is compiled with DD_COUNT defined.
2688<p>
2689
2690<dd> <b>Side Effects</b> None
2691<p>
2692
2693<dt><pre>
2694int <i></i>
2695<a name="Cudd_ReadReorderingCycle"><b>Cudd_ReadReorderingCycle</b></a>(
2696  DdManager * <b>dd</b> <i></i>
2697)
2698</pre>
2699<dd> Reads the reordCycle parameter of the manager. This parameter determines how often the alternate threshold on maximum growth is used in reordering.
2700<p>
2701
2702<dd> <b>Side Effects</b> None
2703<p>
2704
2705<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_ReadMaxGrowthAlternate">Cudd_ReadMaxGrowthAlternate</a>
2706<a href="cuddAllDet.html#Cudd_SetMaxGrowthAlternate">Cudd_SetMaxGrowthAlternate</a>
2707<a href="cuddAllDet.html#Cudd_SetReorderingCycle">Cudd_SetReorderingCycle</a>
2708</code>
2709
2710<dt><pre>
2711long <i></i>
2712<a name="Cudd_ReadReorderingTime"><b>Cudd_ReadReorderingTime</b></a>(
2713  DdManager * <b>dd</b> <i></i>
2714)
2715</pre>
2716<dd> Returns the number of milliseconds spent reordering variables since the manager was initialized. The time spent in collecting garbage before reordering is included.
2717<p>
2718
2719<dd> <b>Side Effects</b> None
2720<p>
2721
2722<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_ReadReorderings">Cudd_ReadReorderings</a>
2723</code>
2724
2725<dt><pre>
2726int <i></i>
2727<a name="Cudd_ReadReorderings"><b>Cudd_ReadReorderings</b></a>(
2728  DdManager * <b>dd</b> <i></i>
2729)
2730</pre>
2731<dd> Returns the number of times reordering has occurred in the manager. 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.
2732<p>
2733
2734<dd> <b>Side Effects</b> None
2735<p>
2736
2737<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_ReduceHeap">Cudd_ReduceHeap</a>
2738<a href="cuddAllDet.html#Cudd_ReadReorderingTime">Cudd_ReadReorderingTime</a>
2739</code>
2740
2741<dt><pre>
2742int <i></i>
2743<a name="Cudd_ReadSiftMaxSwap"><b>Cudd_ReadSiftMaxSwap</b></a>(
2744  DdManager * <b>dd</b> <i></i>
2745)
2746</pre>
2747<dd> Reads the siftMaxSwap parameter of the manager. 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.
2748<p>
2749
2750<dd> <b>Side Effects</b> None
2751<p>
2752
2753<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_ReadSiftMaxVar">Cudd_ReadSiftMaxVar</a>
2754<a href="cuddAllDet.html#Cudd_SetSiftMaxSwap">Cudd_SetSiftMaxSwap</a>
2755</code>
2756
2757<dt><pre>
2758int <i></i>
2759<a name="Cudd_ReadSiftMaxVar"><b>Cudd_ReadSiftMaxVar</b></a>(
2760  DdManager * <b>dd</b> <i></i>
2761)
2762</pre>
2763<dd> Reads the siftMaxVar parameter of the manager. This parameter gives the maximum number of variables that will be sifted for each invocation of sifting.
2764<p>
2765
2766<dd> <b>Side Effects</b> None
2767<p>
2768
2769<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_ReadSiftMaxSwap">Cudd_ReadSiftMaxSwap</a>
2770<a href="cuddAllDet.html#Cudd_SetSiftMaxVar">Cudd_SetSiftMaxVar</a>
2771</code>
2772
2773<dt><pre>
2774int <i></i>
2775<a name="Cudd_ReadSize"><b>Cudd_ReadSize</b></a>(
2776  DdManager * <b>dd</b> <i></i>
2777)
2778</pre>
2779<dd> Returns the number of BDD variables in existance.
2780<p>
2781
2782<dd> <b>Side Effects</b> None
2783<p>
2784
2785<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_ReadZddSize">Cudd_ReadZddSize</a>
2786</code>
2787
2788<dt><pre>
2789unsigned int <i></i>
2790<a name="Cudd_ReadSlots"><b>Cudd_ReadSlots</b></a>(
2791  DdManager * <b>dd</b> <i></i>
2792)
2793</pre>
2794<dd> Returns the total number of slots of the unique table. This number ismainly for diagnostic purposes.
2795<p>
2796
2797<dd> <b>Side Effects</b> None
2798<p>
2799
2800<dt><pre>
2801FILE * <i></i>
2802<a name="Cudd_ReadStderr"><b>Cudd_ReadStderr</b></a>(
2803  DdManager * <b>dd</b> <i></i>
2804)
2805</pre>
2806<dd> Reads the stderr of a manager. 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.
2807<p>
2808
2809<dd> <b>Side Effects</b> None
2810<p>
2811
2812<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_SetStderr">Cudd_SetStderr</a>
2813<a href="cuddAllDet.html#Cudd_ReadStdout">Cudd_ReadStdout</a>
2814</code>
2815
2816<dt><pre>
2817FILE * <i></i>
2818<a name="Cudd_ReadStdout"><b>Cudd_ReadStdout</b></a>(
2819  DdManager * <b>dd</b> <i></i>
2820)
2821</pre>
2822<dd> Reads the stdout of a manager. 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.
2823<p>
2824
2825<dd> <b>Side Effects</b> None
2826<p>
2827
2828<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_SetStdout">Cudd_SetStdout</a>
2829<a href="cuddAllDet.html#Cudd_ReadStderr">Cudd_ReadStderr</a>
2830</code>
2831
2832<dt><pre>
2833double <i></i>
2834<a name="Cudd_ReadSwapSteps"><b>Cudd_ReadSwapSteps</b></a>(
2835  DdManager * <b>dd</b> <i></i>
2836)
2837</pre>
2838<dd> Reads the number of elementary reordering steps.
2839<p>
2840
2841<dd> <b>Side Effects</b> none
2842<p>
2843
2844<dt><pre>
2845int <i></i>
2846<a name="Cudd_ReadSymmviolation"><b>Cudd_ReadSymmviolation</b></a>(
2847  DdManager * <b>dd</b> <i></i>
2848)
2849</pre>
2850<dd> Returns the current value of the symmviolation parameter. 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.
2851<p>
2852
2853<dd> <b>Side Effects</b> None
2854<p>
2855
2856<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_SetSymmviolation">Cudd_SetSymmviolation</a>
2857</code>
2858
2859<dt><pre>
2860MtrNode * <i></i>
2861<a name="Cudd_ReadTree"><b>Cudd_ReadTree</b></a>(
2862  DdManager * <b>dd</b> <i></i>
2863)
2864</pre>
2865<dd> Returns the variable group tree of the manager.
2866<p>
2867
2868<dd> <b>Side Effects</b> None
2869<p>
2870
2871<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_SetTree">Cudd_SetTree</a>
2872<a href="cuddAllDet.html#Cudd_FreeTree">Cudd_FreeTree</a>
2873<a href="cuddAllDet.html#Cudd_ReadZddTree">Cudd_ReadZddTree</a>
2874</code>
2875
2876<dt><pre>
2877double <i></i>
2878<a name="Cudd_ReadUniqueLinks"><b>Cudd_ReadUniqueLinks</b></a>(
2879  DdManager * <b>dd</b> <i></i>
2880)
2881</pre>
2882<dd> 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.
2883<p>
2884
2885<dd> <b>Side Effects</b> None
2886<p>
2887
2888<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_ReadUniqueLookUps">Cudd_ReadUniqueLookUps</a>
2889</code>
2890
2891<dt><pre>
2892double <i></i>
2893<a name="Cudd_ReadUniqueLookUps"><b>Cudd_ReadUniqueLookUps</b></a>(
2894  DdManager * <b>dd</b> <i></i>
2895)
2896</pre>
2897<dd> 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.
2898<p>
2899
2900<dd> <b>Side Effects</b> None
2901<p>
2902
2903<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_ReadUniqueLinks">Cudd_ReadUniqueLinks</a>
2904</code>
2905
2906<dt><pre>
2907double <i></i>
2908<a name="Cudd_ReadUsedSlots"><b>Cudd_ReadUsedSlots</b></a>(
2909  DdManager * <b>dd</b> <i></i>
2910)
2911</pre>
2912<dd> Reads the fraction of used slots in the unique table. 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.
2913<p>
2914
2915<dd> <b>Side Effects</b> None
2916<p>
2917
2918<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_ReadSlots">Cudd_ReadSlots</a>
2919</code>
2920
2921<dt><pre>
2922DdNode * <i></i>
2923<a name="Cudd_ReadVars"><b>Cudd_ReadVars</b></a>(
2924  DdManager * <b>dd</b>, <i></i>
2925  int  <b>i</b> <i></i>
2926)
2927</pre>
2928<dd> 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.
2929<p>
2930
2931<dd> <b>Side Effects</b> None
2932<p>
2933
2934<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_bddIthVar">Cudd_bddIthVar</a>
2935</code>
2936
2937<dt><pre>
2938DdNode * <i></i>
2939<a name="Cudd_ReadZddOne"><b>Cudd_ReadZddOne</b></a>(
2940  DdManager * <b>dd</b>, <i></i>
2941  int  <b>i</b> <i></i>
2942)
2943</pre>
2944<dd> Returns the ZDD for the constant 1 function. 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>.
2945<p>
2946
2947<dd> <b>Side Effects</b> None
2948<p>
2949
2950<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_ReadOne">Cudd_ReadOne</a>
2951</code>
2952
2953<dt><pre>
2954int <i></i>
2955<a name="Cudd_ReadZddSize"><b>Cudd_ReadZddSize</b></a>(
2956  DdManager * <b>dd</b> <i></i>
2957)
2958</pre>
2959<dd> Returns the number of ZDD variables in existance.
2960<p>
2961
2962<dd> <b>Side Effects</b> None
2963<p>
2964
2965<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_ReadSize">Cudd_ReadSize</a>
2966</code>
2967
2968<dt><pre>
2969MtrNode * <i></i>
2970<a name="Cudd_ReadZddTree"><b>Cudd_ReadZddTree</b></a>(
2971  DdManager * <b>dd</b> <i></i>
2972)
2973</pre>
2974<dd> Returns the variable group tree of the manager.
2975<p>
2976
2977<dd> <b>Side Effects</b> None
2978<p>
2979
2980<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_SetZddTree">Cudd_SetZddTree</a>
2981<a href="cuddAllDet.html#Cudd_FreeZddTree">Cudd_FreeZddTree</a>
2982<a href="cuddAllDet.html#Cudd_ReadTree">Cudd_ReadTree</a>
2983</code>
2984
2985<dt><pre>
2986DdNode * <i></i>
2987<a name="Cudd_ReadZero"><b>Cudd_ReadZero</b></a>(
2988  DdManager * <b>dd</b> <i></i>
2989)
2990</pre>
2991<dd> Returns the zero constant of the manager. The zero constant is the arithmetic zero, rather than the logic zero. The latter is the complement of the one constant.
2992<p>
2993
2994<dd> <b>Side Effects</b> None
2995<p>
2996
2997<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_ReadOne">Cudd_ReadOne</a>
2998<a href="cuddAllDet.html#Cudd_ReadLogicZero">Cudd_ReadLogicZero</a>
2999</code>
3000
3001<dt><pre>
3002void <i></i>
3003<a name="Cudd_RecursiveDerefZdd"><b>Cudd_RecursiveDerefZdd</b></a>(
3004  DdManager * <b>table</b>, <i></i>
3005  DdNode * <b>n</b> <i></i>
3006)
3007</pre>
3008<dd> Decreases the reference count of ZDD node n. If n dies, recursively decreases the reference counts of its children. It is used to dispose of a ZDD that is no longer needed.
3009<p>
3010
3011<dd> <b>Side Effects</b> None
3012<p>
3013
3014<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_Deref">Cudd_Deref</a>
3015<a href="cuddAllDet.html#Cudd_Ref">Cudd_Ref</a>
3016<a href="cuddAllDet.html#Cudd_RecursiveDeref">Cudd_RecursiveDeref</a>
3017</code>
3018
3019<dt><pre>
3020void <i></i>
3021<a name="Cudd_RecursiveDeref"><b>Cudd_RecursiveDeref</b></a>(
3022  DdManager * <b>table</b>, <i></i>
3023  DdNode * <b>n</b> <i></i>
3024)
3025</pre>
3026<dd> Decreases the reference count of node n. If n dies, recursively decreases the reference counts of its children. It is used to dispose of a DD that is no longer needed.
3027<p>
3028
3029<dd> <b>Side Effects</b> None
3030<p>
3031
3032<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_Deref">Cudd_Deref</a>
3033<a href="cuddAllDet.html#Cudd_Ref">Cudd_Ref</a>
3034<a href="cuddAllDet.html#Cudd_RecursiveDerefZdd">Cudd_RecursiveDerefZdd</a>
3035</code>
3036
3037<dt><pre>
3038int <i></i>
3039<a name="Cudd_ReduceHeap"><b>Cudd_ReduceHeap</b></a>(
3040  DdManager * <b>table</b>, <i>DD manager</i>
3041  Cudd_ReorderingType  <b>heuristic</b>, <i>method used for reordering</i>
3042  int  <b>minsize</b> <i>bound below which no reordering occurs</i>
3043)
3044</pre>
3045<dd> Main dynamic reordering routine. Calls one of the possible reordering procedures: <ul> <li>Swapping <li>Sifting <li>Symmetric Sifting <li>Group Sifting <li>Window Permutation <li>Simulated Annealing <li>Genetic Algorithm <li>Dynamic Programming (exact) </ul> For sifting, symmetric sifting, group sifting, and window permutation it is possible to request reordering to convergence.<p> The core of all methods is the reordering procedure cuddSwapInPlace() which swaps two adjacent variables and is based on Rudell's paper. Returns 1 in case of success; 0 otherwise. In the case of symmetric sifting (with and without convergence) returns 1 plus the number of symmetric variables, in case of success.
3046<p>
3047
3048<dd> <b>Side Effects</b> Changes the variable order for all diagrams and clears the cache.
3049<p>
3050
3051<dt><pre>
3052void <i></i>
3053<a name="Cudd_Ref"><b>Cudd_Ref</b></a>(
3054  DdNode * <b>n</b> <i></i>
3055)
3056</pre>
3057<dd> Increases the reference count of a node, if it is not saturated.
3058<p>
3059
3060<dd> <b>Side Effects</b> None
3061<p>
3062
3063<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_RecursiveDeref">Cudd_RecursiveDeref</a>
3064<a href="cuddAllDet.html#Cudd_Deref">Cudd_Deref</a>
3065</code>
3066
3067<dt><pre>
3068 <i></i>
3069<a name="Cudd_Regular"><b>Cudd_Regular</b></a>(
3070   <b>node</b> <i></i>
3071)
3072</pre>
3073<dd> Returns the regular version of a pointer.
3074<p>
3075
3076<dd> <b>Side Effects</b> none
3077<p>
3078
3079<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_Complement">Cudd_Complement</a>
3080<a href="cuddAllDet.html#Cudd_IsComplement">Cudd_IsComplement</a>
3081</code>
3082
3083<dt><pre>
3084DdNode * <i></i>
3085<a name="Cudd_RemapOverApprox"><b>Cudd_RemapOverApprox</b></a>(
3086  DdManager * <b>dd</b>, <i>manager</i>
3087  DdNode * <b>f</b>, <i>function to be superset</i>
3088  int  <b>numVars</b>, <i>number of variables in the support of f</i>
3089  int  <b>threshold</b>, <i>when to stop approximation</i>
3090  double  <b>quality</b> <i>minimum improvement for accepted changes</i>
3091)
3092</pre>
3093<dd> Extracts a dense superset from a BDD. The procedure is identical to the underapproximation procedure except for the fact that it works on the complement of the given function. Extracting the subset of the complement function is equivalent to extracting the superset of the function. Returns a pointer to the BDD of the superset if successful. NULL if intermediate result causes the procedure to run out of memory. The parameter numVars is the maximum number of variables to be used in minterm calculation. The optimal number should be as close as possible to the size of the support of f. However, it is safe to pass the value returned by Cudd_ReadSize for numVars when the number of variables is under 1023. If numVars is larger than 1023, it will overflow. If a 0 parameter is passed then the procedure will compute a value which will avoid overflow but will cause underflow with 2046 variables or more.
3094<p>
3095
3096<dd> <b>Side Effects</b> None
3097<p>
3098
3099<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_SupersetHeavyBranch">Cudd_SupersetHeavyBranch</a>
3100<a href="cuddAllDet.html#Cudd_SupersetShortPaths">Cudd_SupersetShortPaths</a>
3101<a href="cuddAllDet.html#Cudd_ReadSize">Cudd_ReadSize</a>
3102</code>
3103
3104<dt><pre>
3105DdNode * <i></i>
3106<a name="Cudd_RemapUnderApprox"><b>Cudd_RemapUnderApprox</b></a>(
3107  DdManager * <b>dd</b>, <i>manager</i>
3108  DdNode * <b>f</b>, <i>function to be subset</i>
3109  int  <b>numVars</b>, <i>number of variables in the support of f</i>
3110  int  <b>threshold</b>, <i>when to stop approximation</i>
3111  double  <b>quality</b> <i>minimum improvement for accepted changes</i>
3112)
3113</pre>
3114<dd> Extracts a dense subset from a BDD. This procedure uses a remapping technique and density as the cost function. Returns a pointer to the BDD of the subset if successful. NULL if the procedure runs out of memory. The parameter numVars is the maximum number of variables to be used in minterm calculation. The optimal number should be as close as possible to the size of the support of f. However, it is safe to pass the value returned by Cudd_ReadSize for numVars when the number of variables is under 1023. If numVars is larger than 1023, it will cause overflow. If a 0 parameter is passed then the procedure will compute a value which will avoid overflow but will cause underflow with 2046 variables or more.
3115<p>
3116
3117<dd> <b>Side Effects</b> None
3118<p>
3119
3120<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_SubsetShortPaths">Cudd_SubsetShortPaths</a>
3121<a href="cuddAllDet.html#Cudd_SubsetHeavyBranch">Cudd_SubsetHeavyBranch</a>
3122<a href="cuddAllDet.html#Cudd_UnderApprox">Cudd_UnderApprox</a>
3123<a href="cuddAllDet.html#Cudd_ReadSize">Cudd_ReadSize</a>
3124</code>
3125
3126<dt><pre>
3127int <i></i>
3128<a name="Cudd_RemoveHook"><b>Cudd_RemoveHook</b></a>(
3129  DdManager * <b>dd</b>, <i></i>
3130  DD_HFP  <b>f</b>, <i></i>
3131  Cudd_HookType  <b>where</b> <i></i>
3132)
3133</pre>
3134<dd> Removes a function from a hook. A hook is a list of application-provided functions called on certain occasions by the package. Returns 1 if successful; 0 the function was not in the list.
3135<p>
3136
3137<dd> <b>Side Effects</b> None
3138<p>
3139
3140<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_AddHook">Cudd_AddHook</a>
3141</code>
3142
3143<dt><pre>
3144int <i></i>
3145<a name="Cudd_ReorderingReporting"><b>Cudd_ReorderingReporting</b></a>(
3146  DdManager * <b>dd</b> <i></i>
3147)
3148</pre>
3149<dd> Returns 1 if reporting of reordering stats is enabled; 0 otherwise.
3150<p>
3151
3152<dd> <b>Side Effects</b> none
3153<p>
3154
3155<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_EnableReorderingReporting">Cudd_EnableReorderingReporting</a>
3156<a href="cuddAllDet.html#Cudd_DisableReorderingReporting">Cudd_DisableReorderingReporting</a>
3157</code>
3158
3159<dt><pre>
3160int <i></i>
3161<a name="Cudd_ReorderingStatusZdd"><b>Cudd_ReorderingStatusZdd</b></a>(
3162  DdManager * <b>unique</b>, <i></i>
3163  Cudd_ReorderingType * <b>method</b> <i></i>
3164)
3165</pre>
3166<dd> Reports the status of automatic dynamic reordering of ZDDs. Parameter method is set to the ZDD reordering method currently selected. Returns 1 if automatic reordering is enabled; 0 otherwise.
3167<p>
3168
3169<dd> <b>Side Effects</b> Parameter method is set to the ZDD reordering method currently selected.
3170<p>
3171
3172<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_AutodynEnableZdd">Cudd_AutodynEnableZdd</a>
3173<a href="cuddAllDet.html#Cudd_AutodynDisableZdd">Cudd_AutodynDisableZdd</a>
3174<a href="cuddAllDet.html#Cudd_ReorderingStatus">Cudd_ReorderingStatus</a>
3175</code>
3176
3177<dt><pre>
3178int <i></i>
3179<a name="Cudd_ReorderingStatus"><b>Cudd_ReorderingStatus</b></a>(
3180  DdManager * <b>unique</b>, <i></i>
3181  Cudd_ReorderingType * <b>method</b> <i></i>
3182)
3183</pre>
3184<dd> Reports the status of automatic dynamic reordering of BDDs and ADDs. Parameter method is set to the reordering method currently selected. Returns 1 if automatic reordering is enabled; 0 otherwise.
3185<p>
3186
3187<dd> <b>Side Effects</b> Parameter method is set to the reordering method currently selected.
3188<p>
3189
3190<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_AutodynEnable">Cudd_AutodynEnable</a>
3191<a href="cuddAllDet.html#Cudd_AutodynDisable">Cudd_AutodynDisable</a>
3192<a href="cuddAllDet.html#Cudd_ReorderingStatusZdd">Cudd_ReorderingStatusZdd</a>
3193</code>
3194
3195<dt><pre>
3196void <i></i>
3197<a name="Cudd_SetArcviolation"><b>Cudd_SetArcviolation</b></a>(
3198  DdManager * <b>dd</b>, <i></i>
3199  int  <b>arcviolation</b> <i></i>
3200)
3201</pre>
3202<dd> Sets the value of the arcviolation parameter. This parameter is used in group sifting 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.
3203<p>
3204
3205<dd> <b>Side Effects</b> None
3206<p>
3207
3208<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_ReadArcviolation">Cudd_ReadArcviolation</a>
3209</code>
3210
3211<dt><pre>
3212void <i></i>
3213<a name="Cudd_SetBackground"><b>Cudd_SetBackground</b></a>(
3214  DdManager * <b>dd</b>, <i></i>
3215  DdNode * <b>bck</b> <i></i>
3216)
3217</pre>
3218<dd> Sets the background constant of the manager. It assumes that the DdNode pointer bck is already referenced.
3219<p>
3220
3221<dd> <b>Side Effects</b> None
3222<p>
3223
3224<dt><pre>
3225void <i></i>
3226<a name="Cudd_SetEpsilon"><b>Cudd_SetEpsilon</b></a>(
3227  DdManager * <b>dd</b>, <i></i>
3228  CUDD_VALUE_TYPE  <b>ep</b> <i></i>
3229)
3230</pre>
3231<dd> Sets the epsilon parameter of the manager to ep. The epsilon parameter control the comparison between floating point numbers.
3232<p>
3233
3234<dd> <b>Side Effects</b> None
3235<p>
3236
3237<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_ReadEpsilon">Cudd_ReadEpsilon</a>
3238</code>
3239
3240<dt><pre>
3241void <i></i>
3242<a name="Cudd_SetGroupcheck"><b>Cudd_SetGroupcheck</b></a>(
3243  DdManager * <b>dd</b>, <i></i>
3244  Cudd_AggregationType  <b>gc</b> <i></i>
3245)
3246</pre>
3247<dd> Sets the parameter groupcheck of the manager to gc. The groupcheck parameter determines the aggregation criterion in group sifting.
3248<p>
3249
3250<dd> <b>Side Effects</b> None
3251<p>
3252
3253<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_ReadGroupCheck">Cudd_ReadGroupCheck</a>
3254</code>
3255
3256<dt><pre>
3257void <i></i>
3258<a name="Cudd_SetLooseUpTo"><b>Cudd_SetLooseUpTo</b></a>(
3259  DdManager * <b>dd</b>, <i></i>
3260  unsigned int  <b>lut</b> <i></i>
3261)
3262</pre>
3263<dd> Sets the looseUpTo parameter of the manager. 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.
3264<p>
3265
3266<dd> <b>Side Effects</b> None
3267<p>
3268
3269<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_ReadLooseUpTo">Cudd_ReadLooseUpTo</a>
3270<a href="cuddAllDet.html#Cudd_SetMinHit">Cudd_SetMinHit</a>
3271</code>
3272
3273<dt><pre>
3274void <i></i>
3275<a name="Cudd_SetMaxCacheHard"><b>Cudd_SetMaxCacheHard</b></a>(
3276  DdManager * <b>dd</b>, <i></i>
3277  unsigned int  <b>mc</b> <i></i>
3278)
3279</pre>
3280<dd> Sets the maxCacheHard parameter of the manager. 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.
3281<p>
3282
3283<dd> <b>Side Effects</b> None
3284<p>
3285
3286<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_ReadMaxCacheHard">Cudd_ReadMaxCacheHard</a>
3287<a href="cuddAllDet.html#Cudd_SetMaxCache">Cudd_SetMaxCache</a>
3288</code>
3289
3290<dt><pre>
3291void <i></i>
3292<a name="Cudd_SetMaxGrowthAlternate"><b>Cudd_SetMaxGrowthAlternate</b></a>(
3293  DdManager * <b>dd</b>, <i></i>
3294  double  <b>mg</b> <i></i>
3295)
3296</pre>
3297<dd> Sets the maxGrowthAlt parameter of the manager. 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.
3298<p>
3299
3300<dd> <b>Side Effects</b> None
3301<p>
3302
3303<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_ReadMaxGrowthAlternate">Cudd_ReadMaxGrowthAlternate</a>
3304<a href="cuddAllDet.html#Cudd_SetMaxGrowth">Cudd_SetMaxGrowth</a>
3305<a href="cuddAllDet.html#Cudd_SetReorderingCycle">Cudd_SetReorderingCycle</a>
3306<a href="cuddAllDet.html#Cudd_ReadReorderingCycle">Cudd_ReadReorderingCycle</a>
3307</code>
3308
3309<dt><pre>
3310void <i></i>
3311<a name="Cudd_SetMaxGrowth"><b>Cudd_SetMaxGrowth</b></a>(
3312  DdManager * <b>dd</b>, <i></i>
3313  double  <b>mg</b> <i></i>
3314)
3315</pre>
3316<dd> Sets the maxGrowth parameter of the manager. 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.
3317<p>
3318
3319<dd> <b>Side Effects</b> None
3320<p>
3321
3322<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_ReadMaxGrowth">Cudd_ReadMaxGrowth</a>
3323<a href="cuddAllDet.html#Cudd_SetMaxGrowthAlternate">Cudd_SetMaxGrowthAlternate</a>
3324</code>
3325
3326<dt><pre>
3327void <i></i>
3328<a name="Cudd_SetMaxLive"><b>Cudd_SetMaxLive</b></a>(
3329  DdManager * <b>dd</b>, <i></i>
3330  unsigned int  <b>maxLive</b> <i></i>
3331)
3332</pre>
3333<dd> Sets the maximum allowed number of live nodes. When this number is exceeded, the package returns NULL.
3334<p>
3335
3336<dd> <b>Side Effects</b> none
3337<p>
3338
3339<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_ReadMaxLive">Cudd_ReadMaxLive</a>
3340</code>
3341
3342<dt><pre>
3343void <i></i>
3344<a name="Cudd_SetMaxMemory"><b>Cudd_SetMaxMemory</b></a>(
3345  DdManager * <b>dd</b>, <i></i>
3346  unsigned long  <b>maxMemory</b> <i></i>
3347)
3348</pre>
3349<dd> Sets the maximum allowed memory. When this number is exceeded, the package returns NULL.
3350<p>
3351
3352<dd> <b>Side Effects</b> none
3353<p>
3354
3355<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_ReadMaxMemory">Cudd_ReadMaxMemory</a>
3356</code>
3357
3358<dt><pre>
3359void <i></i>
3360<a name="Cudd_SetMinHit"><b>Cudd_SetMinHit</b></a>(
3361  DdManager * <b>dd</b>, <i></i>
3362  unsigned int  <b>hr</b> <i></i>
3363)
3364</pre>
3365<dd> 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.
3366<p>
3367
3368<dd> <b>Side Effects</b> None
3369<p>
3370
3371<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_ReadMinHit">Cudd_ReadMinHit</a>
3372</code>
3373
3374<dt><pre>
3375void <i></i>
3376<a name="Cudd_SetNextReordering"><b>Cudd_SetNextReordering</b></a>(
3377  DdManager * <b>dd</b>, <i></i>
3378  unsigned int  <b>next</b> <i></i>
3379)
3380</pre>
3381<dd> Sets the threshold for the next dynamic reordering. 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.
3382<p>
3383
3384<dd> <b>Side Effects</b> None
3385<p>
3386
3387<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_ReadNextReordering">Cudd_ReadNextReordering</a>
3388</code>
3389
3390<dt><pre>
3391void <i></i>
3392<a name="Cudd_SetNumberXovers"><b>Cudd_SetNumberXovers</b></a>(
3393  DdManager * <b>dd</b>, <i></i>
3394  int  <b>numberXovers</b> <i></i>
3395)
3396</pre>
3397<dd> Sets the number of crossovers used by the genetic algorithm for variable reordering. 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.
3398<p>
3399
3400<dd> <b>Side Effects</b> None
3401<p>
3402
3403<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_ReadNumberXovers">Cudd_ReadNumberXovers</a>
3404</code>
3405
3406<dt><pre>
3407void <i></i>
3408<a name="Cudd_SetPopulationSize"><b>Cudd_SetPopulationSize</b></a>(
3409  DdManager * <b>dd</b>, <i></i>
3410  int  <b>populationSize</b> <i></i>
3411)
3412</pre>
3413<dd> Sets the size of the population used by the genetic algorithm for variable reordering. 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.
3414<p>
3415
3416<dd> <b>Side Effects</b> Changes the manager.
3417<p>
3418
3419<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_ReadPopulationSize">Cudd_ReadPopulationSize</a>
3420</code>
3421
3422<dt><pre>
3423void <i></i>
3424<a name="Cudd_SetRecomb"><b>Cudd_SetRecomb</b></a>(
3425  DdManager * <b>dd</b>, <i></i>
3426  int  <b>recomb</b> <i></i>
3427)
3428</pre>
3429<dd> Sets the value of the recombination parameter used in group sifting. 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.
3430<p>
3431
3432<dd> <b>Side Effects</b> Changes the manager.
3433<p>
3434
3435<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_ReadRecomb">Cudd_ReadRecomb</a>
3436</code>
3437
3438<dt><pre>
3439void <i></i>
3440<a name="Cudd_SetReorderingCycle"><b>Cudd_SetReorderingCycle</b></a>(
3441  DdManager * <b>dd</b>, <i></i>
3442  int  <b>cycle</b> <i></i>
3443)
3444</pre>
3445<dd> Sets the reordCycle parameter of the manager. This parameter determines how often the alternate threshold on maximum growth is used in reordering.
3446<p>
3447
3448<dd> <b>Side Effects</b> None
3449<p>
3450
3451<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_ReadMaxGrowthAlternate">Cudd_ReadMaxGrowthAlternate</a>
3452<a href="cuddAllDet.html#Cudd_SetMaxGrowthAlternate">Cudd_SetMaxGrowthAlternate</a>
3453<a href="cuddAllDet.html#Cudd_ReadReorderingCycle">Cudd_ReadReorderingCycle</a>
3454</code>
3455
3456<dt><pre>
3457void <i></i>
3458<a name="Cudd_SetSiftMaxSwap"><b>Cudd_SetSiftMaxSwap</b></a>(
3459  DdManager * <b>dd</b>, <i></i>
3460  int  <b>sms</b> <i></i>
3461)
3462</pre>
3463<dd> Sets the siftMaxSwap parameter of the manager. 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.
3464<p>
3465
3466<dd> <b>Side Effects</b> None
3467<p>
3468
3469<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_SetSiftMaxVar">Cudd_SetSiftMaxVar</a>
3470<a href="cuddAllDet.html#Cudd_ReadSiftMaxSwap">Cudd_ReadSiftMaxSwap</a>
3471</code>
3472
3473<dt><pre>
3474void <i></i>
3475<a name="Cudd_SetSiftMaxVar"><b>Cudd_SetSiftMaxVar</b></a>(
3476  DdManager * <b>dd</b>, <i></i>
3477  int  <b>smv</b> <i></i>
3478)
3479</pre>
3480<dd> Sets the siftMaxVar parameter of the manager. This parameter gives the maximum number of variables that will be sifted for each invocation of sifting.
3481<p>
3482
3483<dd> <b>Side Effects</b> None
3484<p>
3485
3486<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_SetSiftMaxSwap">Cudd_SetSiftMaxSwap</a>
3487<a href="cuddAllDet.html#Cudd_ReadSiftMaxVar">Cudd_ReadSiftMaxVar</a>
3488</code>
3489
3490<dt><pre>
3491void <i></i>
3492<a name="Cudd_SetStderr"><b>Cudd_SetStderr</b></a>(
3493  DdManager * <b>dd</b>, <i></i>
3494  FILE * <b>fp</b> <i></i>
3495)
3496</pre>
3497<dd> Sets the stderr of a manager.
3498<p>
3499
3500<dd> <b>Side Effects</b> None
3501<p>
3502
3503<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_ReadStderr">Cudd_ReadStderr</a>
3504<a href="cuddAllDet.html#Cudd_SetStdout">Cudd_SetStdout</a>
3505</code>
3506
3507<dt><pre>
3508void <i></i>
3509<a name="Cudd_SetStdout"><b>Cudd_SetStdout</b></a>(
3510  DdManager * <b>dd</b>, <i></i>
3511  FILE * <b>fp</b> <i></i>
3512)
3513</pre>
3514<dd> Sets the stdout of a manager.
3515<p>
3516
3517<dd> <b>Side Effects</b> None
3518<p>
3519
3520<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_ReadStdout">Cudd_ReadStdout</a>
3521<a href="cuddAllDet.html#Cudd_SetStderr">Cudd_SetStderr</a>
3522</code>
3523
3524<dt><pre>
3525void <i></i>
3526<a name="Cudd_SetSymmviolation"><b>Cudd_SetSymmviolation</b></a>(
3527  DdManager * <b>dd</b>, <i></i>
3528  int  <b>symmviolation</b> <i></i>
3529)
3530</pre>
3531<dd> Sets the value of the symmviolation parameter. 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.
3532<p>
3533
3534<dd> <b>Side Effects</b> Changes the manager.
3535<p>
3536
3537<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_ReadSymmviolation">Cudd_ReadSymmviolation</a>
3538</code>
3539
3540<dt><pre>
3541void <i></i>
3542<a name="Cudd_SetTree"><b>Cudd_SetTree</b></a>(
3543  DdManager * <b>dd</b>, <i></i>
3544  MtrNode * <b>tree</b> <i></i>
3545)
3546</pre>
3547<dd> Sets the variable group tree of the manager.
3548<p>
3549
3550<dd> <b>Side Effects</b> None
3551<p>
3552
3553<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_FreeTree">Cudd_FreeTree</a>
3554<a href="cuddAllDet.html#Cudd_ReadTree">Cudd_ReadTree</a>
3555<a href="cuddAllDet.html#Cudd_SetZddTree">Cudd_SetZddTree</a>
3556</code>
3557
3558<dt><pre>
3559int <i></i>
3560<a name="Cudd_SetVarMap"><b>Cudd_SetVarMap</b></a>(
3561  DdManager * <b>manager</b>, <i>DD manager</i>
3562  DdNode ** <b>x</b>, <i>first array of variables</i>
3563  DdNode ** <b>y</b>, <i>second array of variables</i>
3564  int  <b>n</b> <i>length of both arrays</i>
3565)
3566</pre>
3567<dd> Registers with the manager a variable mapping described by two sets of variables. This variable mapping is then used by functions like Cudd_bddVarMap. This function is convenient for those applications that perform the same mapping several times. However, if several different permutations are used, it may be more efficient not to rely on the registered mapping, because changing mapping causes the cache to be cleared. (The initial setting, however, does not clear the cache.) The two sets of variables (x and y) must have the same size (x and y). The size is given by n. The two sets of variables are normally disjoint, but this restriction is not imposeded by the function. When new variables are created, the map is automatically extended (each new variable maps to itself). The typical use, however, is to wait until all variables are created, and then create the map. Returns 1 if the mapping is successfully registered with the manager; 0 otherwise.
3568<p>
3569
3570<dd> <b>Side Effects</b> Modifies the manager. May clear the cache.
3571<p>
3572
3573<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_bddVarMap">Cudd_bddVarMap</a>
3574<a href="cuddAllDet.html#Cudd_bddPermute">Cudd_bddPermute</a>
3575<a href="cuddAllDet.html#Cudd_bddSwapVariables">Cudd_bddSwapVariables</a>
3576</code>
3577
3578<dt><pre>
3579void <i></i>
3580<a name="Cudd_SetZddTree"><b>Cudd_SetZddTree</b></a>(
3581  DdManager * <b>dd</b>, <i></i>
3582  MtrNode * <b>tree</b> <i></i>
3583)
3584</pre>
3585<dd> Sets the ZDD variable group tree of the manager.
3586<p>
3587
3588<dd> <b>Side Effects</b> None
3589<p>
3590
3591<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_FreeZddTree">Cudd_FreeZddTree</a>
3592<a href="cuddAllDet.html#Cudd_ReadZddTree">Cudd_ReadZddTree</a>
3593<a href="cuddAllDet.html#Cudd_SetTree">Cudd_SetTree</a>
3594</code>
3595
3596<dt><pre>
3597int <i></i>
3598<a name="Cudd_SharingSize"><b>Cudd_SharingSize</b></a>(
3599  DdNode ** <b>nodeArray</b>, <i></i>
3600  int  <b>n</b> <i></i>
3601)
3602</pre>
3603<dd> Counts the number of nodes in an array of DDs. Shared nodes are counted only once. Returns the total number of nodes.
3604<p>
3605
3606<dd> <b>Side Effects</b> None
3607<p>
3608
3609<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_DagSize">Cudd_DagSize</a>
3610</code>
3611
3612<dt><pre>
3613int <i></i>
3614<a name="Cudd_ShortestLength"><b>Cudd_ShortestLength</b></a>(
3615  DdManager * <b>manager</b>, <i></i>
3616  DdNode * <b>f</b>, <i></i>
3617  int * <b>weight</b> <i></i>
3618)
3619</pre>
3620<dd> Find the length of the shortest path(s) in a DD. f is the DD we want to get the shortest path for; weight[i] is the weight of the THEN edge coming from the node whose index is i. All ELSE edges have 0 weight. Returns the length of the shortest path(s) if successful; CUDD_OUT_OF_MEM otherwise.
3621<p>
3622
3623<dd> <b>Side Effects</b> None
3624<p>
3625
3626<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_ShortestPath">Cudd_ShortestPath</a>
3627</code>
3628
3629<dt><pre>
3630DdNode * <i></i>
3631<a name="Cudd_ShortestPath"><b>Cudd_ShortestPath</b></a>(
3632  DdManager * <b>manager</b>, <i></i>
3633  DdNode * <b>f</b>, <i></i>
3634  int * <b>weight</b>, <i></i>
3635  int * <b>support</b>, <i></i>
3636  int * <b>length</b> <i></i>
3637)
3638</pre>
3639<dd> Finds a shortest path in a DD. f is the DD we want to get the shortest path for; weight[i] is the weight of the THEN arc coming from the node whose index is i. If weight is NULL, then unit weights are assumed for all THEN arcs. All ELSE arcs have 0 weight. If non-NULL, both weight and support should point to arrays with at least as many entries as there are variables in the manager. Returns the shortest path as the BDD of a cube.
3640<p>
3641
3642<dd> <b>Side Effects</b> support contains on return the true support of f. If support is NULL on entry, then Cudd_ShortestPath does not compute the true support info. length contains the length of the path.
3643<p>
3644
3645<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_ShortestLength">Cudd_ShortestLength</a>
3646<a href="cuddAllDet.html#Cudd_LargestCube">Cudd_LargestCube</a>
3647</code>
3648
3649<dt><pre>
3650int <i></i>
3651<a name="Cudd_ShuffleHeap"><b>Cudd_ShuffleHeap</b></a>(
3652  DdManager * <b>table</b>, <i>DD manager</i>
3653  int * <b>permutation</b> <i>required variable permutation</i>
3654)
3655</pre>
3656<dd> Reorders variables according to given permutation. The i-th entry of the permutation array contains the index of the variable that should be brought to the i-th level. The size of the array should be equal or greater to the number of variables currently in use. Returns 1 in case of success; 0 otherwise.
3657<p>
3658
3659<dd> <b>Side Effects</b> Changes the variable order for all diagrams and clears the cache.
3660<p>
3661
3662<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_ReduceHeap">Cudd_ReduceHeap</a>
3663</code>
3664
3665<dt><pre>
3666DdNode * <i></i>
3667<a name="Cudd_SolveEqn"><b>Cudd_SolveEqn</b></a>(
3668  DdManager * <b>bdd</b>, <i></i>
3669  DdNode * <b>F</b>, <i>the left-hand side of the equation</i>
3670  DdNode * <b>Y</b>, <i>the cube of the y variables</i>
3671  DdNode ** <b>G</b>, <i>the array of solutions (return parameter)</i>
3672  int ** <b>yIndex</b>, <i>index of y variables</i>
3673  int  <b>n</b> <i>numbers of unknowns</i>
3674)
3675</pre>
3676<dd> Implements the solution for F(x,y) = 0. The return value is the consistency condition. The y variables are the unknowns and the remaining variables are the parameters. Returns the consistency condition if successful; NULL otherwise. Cudd_SolveEqn allocates an array and fills it with the indices of the unknowns. This array is used by Cudd_VerifySol.
3677<p>
3678
3679<dd> <b>Side Effects</b> The solution is returned in G; the indices of the y variables are returned in yIndex.
3680<p>
3681
3682<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_VerifySol">Cudd_VerifySol</a>
3683</code>
3684
3685<dt><pre>
3686DdNode * <i></i>
3687<a name="Cudd_SplitSet"><b>Cudd_SplitSet</b></a>(
3688  DdManager * <b>manager</b>, <i></i>
3689  DdNode * <b>S</b>, <i></i>
3690  DdNode ** <b>xVars</b>, <i></i>
3691  int  <b>n</b>, <i></i>
3692  double  <b>m</b> <i></i>
3693)
3694</pre>
3695<dd> Returns <code>m</code> minterms from a BDD whose support has <code>n</code> variables at most. The procedure tries to create as few extra nodes as possible. The function represented by <code>S</code> depends on at most <code>n</code> of the variables in <code>xVars</code>. Returns a BDD with <code>m</code> minterms of the on-set of S if successful; NULL otherwise.
3696<p>
3697
3698<dd> <b>Side Effects</b> None
3699<p>
3700
3701<dt><pre>
3702void <i></i>
3703<a name="Cudd_Srandom"><b>Cudd_Srandom</b></a>(
3704  long  <b>seed</b> <i></i>
3705)
3706</pre>
3707<dd> Initializer for the portable number generator based on ran2 in "Numerical Recipes in C." The input is the seed for the generator. If it is negative, its absolute value is taken as seed. If it is 0, then 1 is taken as seed. The initialized sets up the two recurrences used to generate a long-period stream, and sets up the shuffle table.
3708<p>
3709
3710<dd> <b>Side Effects</b> None
3711<p>
3712
3713<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_Random">Cudd_Random</a>
3714</code>
3715
3716<dt><pre>
3717int <i></i>
3718<a name="Cudd_StdPostReordHook"><b>Cudd_StdPostReordHook</b></a>(
3719  DdManager * <b>dd</b>, <i></i>
3720  const char * <b>str</b>, <i></i>
3721  void * <b>data</b> <i></i>
3722)
3723</pre>
3724<dd> Sample hook function to call after reordering. Prints on the manager's stdout final size and reordering time. Returns 1 if successful; 0 otherwise.
3725<p>
3726
3727<dd> <b>Side Effects</b> None
3728<p>
3729
3730<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_StdPreReordHook">Cudd_StdPreReordHook</a>
3731</code>
3732
3733<dt><pre>
3734int <i></i>
3735<a name="Cudd_StdPreReordHook"><b>Cudd_StdPreReordHook</b></a>(
3736  DdManager * <b>dd</b>, <i></i>
3737  const char * <b>str</b>, <i></i>
3738  void * <b>data</b> <i></i>
3739)
3740</pre>
3741<dd> Sample hook function to call before reordering. Prints on the manager's stdout reordering method and initial size. Returns 1 if successful; 0 otherwise.
3742<p>
3743
3744<dd> <b>Side Effects</b> None
3745<p>
3746
3747<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_StdPostReordHook">Cudd_StdPostReordHook</a>
3748</code>
3749
3750<dt><pre>
3751DdNode * <i></i>
3752<a name="Cudd_SubsetCompress"><b>Cudd_SubsetCompress</b></a>(
3753  DdManager * <b>dd</b>, <i>manager</i>
3754  DdNode * <b>f</b>, <i>BDD whose subset is sought</i>
3755  int  <b>nvars</b>, <i>number of variables in the support of f</i>
3756  int  <b>threshold</b> <i>maximum number of nodes in the subset</i>
3757)
3758</pre>
3759<dd> Finds a dense subset of BDD <code>f</code>. Density is the ratio of number of minterms to number of nodes. Uses several techniques in series. It is more expensive than other subsetting procedures, but often produces better results. See Cudd_SubsetShortPaths for a description of the threshold and nvars parameters. Returns a pointer to the result if successful; NULL otherwise.
3760<p>
3761
3762<dd> <b>Side Effects</b> None
3763<p>
3764
3765<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_SubsetRemap">Cudd_SubsetRemap</a>
3766<a href="cuddAllDet.html#Cudd_SubsetShortPaths">Cudd_SubsetShortPaths</a>
3767<a href="cuddAllDet.html#Cudd_SubsetHeavyBranch">Cudd_SubsetHeavyBranch</a>
3768<a href="cuddAllDet.html#Cudd_bddSqueeze">Cudd_bddSqueeze</a>
3769</code>
3770
3771<dt><pre>
3772DdNode * <i></i>
3773<a name="Cudd_SubsetHeavyBranch"><b>Cudd_SubsetHeavyBranch</b></a>(
3774  DdManager * <b>dd</b>, <i>manager</i>
3775  DdNode * <b>f</b>, <i>function to be subset</i>
3776  int  <b>numVars</b>, <i>number of variables in the support of f</i>
3777  int  <b>threshold</b> <i>maximum number of nodes in the subset</i>
3778)
3779</pre>
3780<dd> Extracts a dense subset from a BDD. This procedure builds a subset by throwing away one of the children of each node, starting from the root, until the result is small enough. The child that is eliminated from the result is the one that contributes the fewer minterms. Returns a pointer to the BDD of the subset if successful. NULL if the procedure runs out of memory. The parameter numVars is the maximum number of variables to be used in minterm calculation and node count calculation. The optimal number should be as close as possible to the size of the support of f. However, it is safe to pass the value returned by Cudd_ReadSize for numVars when the number of variables is under 1023. If numVars is larger than 1023, it will overflow. If a 0 parameter is passed then the procedure will compute a value which will avoid overflow but will cause underflow with 2046 variables or more.
3781<p>
3782
3783<dd> <b>Side Effects</b> None
3784<p>
3785
3786<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_SubsetShortPaths">Cudd_SubsetShortPaths</a>
3787<a href="cuddAllDet.html#Cudd_SupersetHeavyBranch">Cudd_SupersetHeavyBranch</a>
3788<a href="cuddAllDet.html#Cudd_ReadSize">Cudd_ReadSize</a>
3789</code>
3790
3791<dt><pre>
3792DdNode * <i></i>
3793<a name="Cudd_SubsetShortPaths"><b>Cudd_SubsetShortPaths</b></a>(
3794  DdManager * <b>dd</b>, <i>manager</i>
3795  DdNode * <b>f</b>, <i>function to be subset</i>
3796  int  <b>numVars</b>, <i>number of variables in the support of f</i>
3797  int  <b>threshold</b>, <i>maximum number of nodes in the subset</i>
3798  int  <b>hardlimit</b> <i>flag: 1 if threshold is a hard limit</i>
3799)
3800</pre>
3801<dd> Extracts a dense subset from a BDD. This procedure tries to preserve the shortest paths of the input BDD, because they give many minterms and contribute few nodes. This procedure may increase the number of nodes in trying to create the subset or reduce the number of nodes due to recombination as compared to the original BDD. Hence the threshold may not be strictly adhered to. In practice, recombination overshadows the increase in the number of nodes and results in small BDDs as compared to the threshold. The hardlimit specifies whether threshold needs to be strictly adhered to. If it is set to 1, the procedure ensures that result is never larger than the specified limit but may be considerably less than the threshold. Returns a pointer to the BDD for the subset if successful; NULL otherwise. The value for numVars should be as close as possible to the size of the support of f for better efficiency. However, it is safe to pass the value returned by Cudd_ReadSize for numVars. If 0 is passed, then the value returned by Cudd_ReadSize is used.
3802<p>
3803
3804<dd> <b>Side Effects</b> None
3805<p>
3806
3807<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_SupersetShortPaths">Cudd_SupersetShortPaths</a>
3808<a href="cuddAllDet.html#Cudd_SubsetHeavyBranch">Cudd_SubsetHeavyBranch</a>
3809<a href="cuddAllDet.html#Cudd_ReadSize">Cudd_ReadSize</a>
3810</code>
3811
3812<dt><pre>
3813DdNode * <i></i>
3814<a name="Cudd_SubsetWithMaskVars"><b>Cudd_SubsetWithMaskVars</b></a>(
3815  DdManager * <b>dd</b>, <i>manager</i>
3816  DdNode * <b>f</b>, <i>function from which to pick a cube</i>
3817  DdNode ** <b>vars</b>, <i>array of variables</i>
3818  int  <b>nvars</b>, <i>size of <code>vars</code></i>
3819  DdNode ** <b>maskVars</b>, <i>array of variables</i>
3820  int  <b>mvars</b> <i>size of <code>maskVars</code></i>
3821)
3822</pre>
3823<dd> Extracts a subset from a BDD in the following procedure. 1. Compute the weight for each mask variable by counting the number of minterms for both positive and negative cofactors of the BDD with respect to each mask variable. (weight = #positive - #negative) 2. Find a representative cube of the BDD by using the weight. From the top variable of the BDD, for each variable, if the weight is greater than 0.0, choose THEN branch, othereise ELSE branch, until meeting the constant 1. 3. Quantify out the variables not in maskVars from the representative cube and if a variable in maskVars is don't care, replace the variable with a constant(1 or 0) depending on the weight. 4. Make a subset of the BDD by multiplying with the modified cube.
3824<p>
3825
3826<dd> <b>Side Effects</b> None
3827<p>
3828
3829<dt><pre>
3830DdNode * <i></i>
3831<a name="Cudd_SupersetCompress"><b>Cudd_SupersetCompress</b></a>(
3832  DdManager * <b>dd</b>, <i>manager</i>
3833  DdNode * <b>f</b>, <i>BDD whose superset is sought</i>
3834  int  <b>nvars</b>, <i>number of variables in the support of f</i>
3835  int  <b>threshold</b> <i>maximum number of nodes in the superset</i>
3836)
3837</pre>
3838<dd> Finds a dense superset of BDD <code>f</code>. Density is the ratio of number of minterms to number of nodes. Uses several techniques in series. It is more expensive than other supersetting procedures, but often produces better results. See Cudd_SupersetShortPaths for a description of the threshold and nvars parameters. Returns a pointer to the result if successful; NULL otherwise.
3839<p>
3840
3841<dd> <b>Side Effects</b> None
3842<p>
3843
3844<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_SubsetCompress">Cudd_SubsetCompress</a>
3845<a href="cuddAllDet.html#Cudd_SupersetRemap">Cudd_SupersetRemap</a>
3846<a href="cuddAllDet.html#Cudd_SupersetShortPaths">Cudd_SupersetShortPaths</a>
3847<a href="cuddAllDet.html#Cudd_SupersetHeavyBranch">Cudd_SupersetHeavyBranch</a>
3848<a href="cuddAllDet.html#Cudd_bddSqueeze">Cudd_bddSqueeze</a>
3849</code>
3850
3851<dt><pre>
3852DdNode * <i></i>
3853<a name="Cudd_SupersetHeavyBranch"><b>Cudd_SupersetHeavyBranch</b></a>(
3854  DdManager * <b>dd</b>, <i>manager</i>
3855  DdNode * <b>f</b>, <i>function to be superset</i>
3856  int  <b>numVars</b>, <i>number of variables in the support of f</i>
3857  int  <b>threshold</b> <i>maximum number of nodes in the superset</i>
3858)
3859</pre>
3860<dd> Extracts a dense superset from a BDD. The procedure is identical to the subset procedure except for the fact that it receives the complement of the given function. Extracting the subset of the complement function is equivalent to extracting the superset of the function. This procedure builds a superset by throwing away one of the children of each node starting from the root of the complement function, until the result is small enough. The child that is eliminated from the result is the one that contributes the fewer minterms. Returns a pointer to the BDD of the superset if successful. NULL if intermediate result causes the procedure to run out of memory. The parameter numVars is the maximum number of variables to be used in minterm calculation and node count calculation. The optimal number should be as close as possible to the size of the support of f. However, it is safe to pass the value returned by Cudd_ReadSize for numVars when the number of variables is under 1023. If numVars is larger than 1023, it will overflow. If a 0 parameter is passed then the procedure will compute a value which will avoid overflow but will cause underflow with 2046 variables or more.
3861<p>
3862
3863<dd> <b>Side Effects</b> None
3864<p>
3865
3866<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_SubsetHeavyBranch">Cudd_SubsetHeavyBranch</a>
3867<a href="cuddAllDet.html#Cudd_SupersetShortPaths">Cudd_SupersetShortPaths</a>
3868<a href="cuddAllDet.html#Cudd_ReadSize">Cudd_ReadSize</a>
3869</code>
3870
3871<dt><pre>
3872DdNode * <i></i>
3873<a name="Cudd_SupersetShortPaths"><b>Cudd_SupersetShortPaths</b></a>(
3874  DdManager * <b>dd</b>, <i>manager</i>
3875  DdNode * <b>f</b>, <i>function to be superset</i>
3876  int  <b>numVars</b>, <i>number of variables in the support of f</i>
3877  int  <b>threshold</b>, <i>maximum number of nodes in the subset</i>
3878  int  <b>hardlimit</b> <i>flag: 1 if threshold is a hard limit</i>
3879)
3880</pre>
3881<dd> Extracts a dense superset from a BDD. The procedure is identical to the subset procedure except for the fact that it receives the complement of the given function. Extracting the subset of the complement function is equivalent to extracting the superset of the function. This procedure tries to preserve the shortest paths of the complement BDD, because they give many minterms and contribute few nodes. This procedure may increase the number of nodes in trying to create the superset or reduce the number of nodes due to recombination as compared to the original BDD. Hence the threshold may not be strictly adhered to. In practice, recombination overshadows the increase in the number of nodes and results in small BDDs as compared to the threshold. The hardlimit specifies whether threshold needs to be strictly adhered to. If it is set to 1, the procedure ensures that result is never larger than the specified limit but may be considerably less than the threshold. Returns a pointer to the BDD for the superset if successful; NULL otherwise. The value for numVars should be as close as possible to the size of the support of f for better efficiency. However, it is safe to pass the value returned by Cudd_ReadSize for numVar. If 0 is passed, then the value returned by Cudd_ReadSize is used.
3882<p>
3883
3884<dd> <b>Side Effects</b> None
3885<p>
3886
3887<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_SubsetShortPaths">Cudd_SubsetShortPaths</a>
3888<a href="cuddAllDet.html#Cudd_SupersetHeavyBranch">Cudd_SupersetHeavyBranch</a>
3889<a href="cuddAllDet.html#Cudd_ReadSize">Cudd_ReadSize</a>
3890</code>
3891
3892<dt><pre>
3893int * <i></i>
3894<a name="Cudd_SupportIndex"><b>Cudd_SupportIndex</b></a>(
3895  DdManager * <b>dd</b>, <i>manager</i>
3896  DdNode * <b>f</b> <i>DD whose support is sought</i>
3897)
3898</pre>
3899<dd> Finds the variables on which a DD depends. Returns an index array of the variables if successful; NULL otherwise. The size of the array equals the number of variables in the manager. Each entry of the array is 1 if the corresponding variable is in the support of the DD and 0 otherwise.
3900<p>
3901
3902<dd> <b>Side Effects</b> None
3903<p>
3904
3905<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_Support">Cudd_Support</a>
3906<a href="cuddAllDet.html#Cudd_VectorSupport">Cudd_VectorSupport</a>
3907<a href="cuddAllDet.html#Cudd_ClassifySupport">Cudd_ClassifySupport</a>
3908</code>
3909
3910<dt><pre>
3911int <i></i>
3912<a name="Cudd_SupportSize"><b>Cudd_SupportSize</b></a>(
3913  DdManager * <b>dd</b>, <i>manager</i>
3914  DdNode * <b>f</b> <i>DD whose support size is sought</i>
3915)
3916</pre>
3917<dd> Counts the variables on which a DD depends. Returns the number of the variables if successful; CUDD_OUT_OF_MEM otherwise.
3918<p>
3919
3920<dd> <b>Side Effects</b> None
3921<p>
3922
3923<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_Support">Cudd_Support</a>
3924</code>
3925
3926<dt><pre>
3927DdNode * <i></i>
3928<a name="Cudd_Support"><b>Cudd_Support</b></a>(
3929  DdManager * <b>dd</b>, <i>manager</i>
3930  DdNode * <b>f</b> <i>DD whose support is sought</i>
3931)
3932</pre>
3933<dd> Finds the variables on which a DD depends. Returns a BDD consisting of the product of the variables if successful; NULL otherwise.
3934<p>
3935
3936<dd> <b>Side Effects</b> None
3937<p>
3938
3939<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_VectorSupport">Cudd_VectorSupport</a>
3940<a href="cuddAllDet.html#Cudd_ClassifySupport">Cudd_ClassifySupport</a>
3941</code>
3942
3943<dt><pre>
3944void <i></i>
3945<a name="Cudd_SymmProfile"><b>Cudd_SymmProfile</b></a>(
3946  DdManager * <b>table</b>, <i></i>
3947  int  <b>lower</b>, <i></i>
3948  int  <b>upper</b> <i></i>
3949)
3950</pre>
3951<dd> Prints statistics on symmetric variables.
3952<p>
3953
3954<dd> <b>Side Effects</b> None
3955<p>
3956
3957<dt><pre>
3958void <i></i>
3959<a name="Cudd_TurnOffCountDead"><b>Cudd_TurnOffCountDead</b></a>(
3960  DdManager * <b>dd</b> <i></i>
3961)
3962</pre>
3963<dd> Causes the dead nodes not to be counted towards triggering reordering. 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.
3964<p>
3965
3966<dd> <b>Side Effects</b> Changes the manager.
3967<p>
3968
3969<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_TurnOnCountDead">Cudd_TurnOnCountDead</a>
3970<a href="cuddAllDet.html#Cudd_DeadAreCounted">Cudd_DeadAreCounted</a>
3971</code>
3972
3973<dt><pre>
3974void <i></i>
3975<a name="Cudd_TurnOnCountDead"><b>Cudd_TurnOnCountDead</b></a>(
3976  DdManager * <b>dd</b> <i></i>
3977)
3978</pre>
3979<dd> Causes the dead nodes to be counted towards triggering reordering. This causes more frequent reorderings. By default dead nodes are not counted.
3980<p>
3981
3982<dd> <b>Side Effects</b> Changes the manager.
3983<p>
3984
3985<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_TurnOffCountDead">Cudd_TurnOffCountDead</a>
3986<a href="cuddAllDet.html#Cudd_DeadAreCounted">Cudd_DeadAreCounted</a>
3987</code>
3988
3989<dt><pre>
3990 <i></i>
3991<a name="Cudd_T"><b>Cudd_T</b></a>(
3992   <b>node</b> <i></i>
3993)
3994</pre>
3995<dd> Returns the then child of an internal node. If <code>node</code> is a constant node, the result is unpredictable.
3996<p>
3997
3998<dd> <b>Side Effects</b> none
3999<p>
4000
4001<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_E">Cudd_E</a>
4002<a href="cuddAllDet.html#Cudd_V">Cudd_V</a>
4003</code>
4004
4005<dt><pre>
4006DdNode * <i></i>
4007<a name="Cudd_UnderApprox"><b>Cudd_UnderApprox</b></a>(
4008  DdManager * <b>dd</b>, <i>manager</i>
4009  DdNode * <b>f</b>, <i>function to be subset</i>
4010  int  <b>numVars</b>, <i>number of variables in the support of f</i>
4011  int  <b>threshold</b>, <i>when to stop approximation</i>
4012  int  <b>safe</b>, <i>enforce safe approximation</i>
4013  double  <b>quality</b> <i>minimum improvement for accepted changes</i>
4014)
4015</pre>
4016<dd> Extracts a dense subset from a BDD. This procedure uses a variant of Tom Shiple's underapproximation method. The main difference from the original method is that density is used as cost function. Returns a pointer to the BDD of the subset if successful. NULL if the procedure runs out of memory. The parameter numVars is the maximum number of variables to be used in minterm calculation. The optimal number should be as close as possible to the size of the support of f. However, it is safe to pass the value returned by Cudd_ReadSize for numVars when the number of variables is under 1023. If numVars is larger than 1023, it will cause overflow. If a 0 parameter is passed then the procedure will compute a value which will avoid overflow but will cause underflow with 2046 variables or more.
4017<p>
4018
4019<dd> <b>Side Effects</b> None
4020<p>
4021
4022<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_SubsetShortPaths">Cudd_SubsetShortPaths</a>
4023<a href="cuddAllDet.html#Cudd_SubsetHeavyBranch">Cudd_SubsetHeavyBranch</a>
4024<a href="cuddAllDet.html#Cudd_ReadSize">Cudd_ReadSize</a>
4025</code>
4026
4027<dt><pre>
4028int * <i></i>
4029<a name="Cudd_VectorSupportIndex"><b>Cudd_VectorSupportIndex</b></a>(
4030  DdManager * <b>dd</b>, <i>manager</i>
4031  DdNode ** <b>F</b>, <i>array of DDs whose support is sought</i>
4032  int  <b>n</b> <i>size of the array</i>
4033)
4034</pre>
4035<dd> Finds the variables on which a set of DDs depends. The set must contain either BDDs and ADDs, or ZDDs. Returns an index array of the variables if successful; NULL otherwise.
4036<p>
4037
4038<dd> <b>Side Effects</b> None
4039<p>
4040
4041<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_SupportIndex">Cudd_SupportIndex</a>
4042<a href="cuddAllDet.html#Cudd_VectorSupport">Cudd_VectorSupport</a>
4043<a href="cuddAllDet.html#Cudd_ClassifySupport">Cudd_ClassifySupport</a>
4044</code>
4045
4046<dt><pre>
4047int <i></i>
4048<a name="Cudd_VectorSupportSize"><b>Cudd_VectorSupportSize</b></a>(
4049  DdManager * <b>dd</b>, <i>manager</i>
4050  DdNode ** <b>F</b>, <i>array of DDs whose support is sought</i>
4051  int  <b>n</b> <i>size of the array</i>
4052)
4053</pre>
4054<dd> Counts the variables on which a set of DDs depends. The set must contain either BDDs and ADDs, or ZDDs. Returns the number of the variables if successful; CUDD_OUT_OF_MEM otherwise.
4055<p>
4056
4057<dd> <b>Side Effects</b> None
4058<p>
4059
4060<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_VectorSupport">Cudd_VectorSupport</a>
4061<a href="cuddAllDet.html#Cudd_SupportSize">Cudd_SupportSize</a>
4062</code>
4063
4064<dt><pre>
4065DdNode * <i></i>
4066<a name="Cudd_VectorSupport"><b>Cudd_VectorSupport</b></a>(
4067  DdManager * <b>dd</b>, <i>manager</i>
4068  DdNode ** <b>F</b>, <i>array of DDs whose support is sought</i>
4069  int  <b>n</b> <i>size of the array</i>
4070)
4071</pre>
4072<dd> Finds the variables on which a set of DDs depends. The set must contain either BDDs and ADDs, or ZDDs. Returns a BDD consisting of the product of the variables if successful; NULL otherwise.
4073<p>
4074
4075<dd> <b>Side Effects</b> None
4076<p>
4077
4078<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_Support">Cudd_Support</a>
4079<a href="cuddAllDet.html#Cudd_ClassifySupport">Cudd_ClassifySupport</a>
4080</code>
4081
4082<dt><pre>
4083DdNode * <i></i>
4084<a name="Cudd_VerifySol"><b>Cudd_VerifySol</b></a>(
4085  DdManager * <b>bdd</b>, <i></i>
4086  DdNode * <b>F</b>, <i>the left-hand side of the equation</i>
4087  DdNode ** <b>G</b>, <i>the array of solutions</i>
4088  int * <b>yIndex</b>, <i>index of y variables</i>
4089  int  <b>n</b> <i>numbers of unknowns</i>
4090)
4091</pre>
4092<dd> Checks the solution of F(x,y) = 0. This procedure substitutes the solution components for the unknowns of F and returns the resulting BDD for F.
4093<p>
4094
4095<dd> <b>Side Effects</b> Frees the memory pointed by yIndex.
4096<p>
4097
4098<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_SolveEqn">Cudd_SolveEqn</a>
4099</code>
4100
4101<dt><pre>
4102 <i></i>
4103<a name="Cudd_V"><b>Cudd_V</b></a>(
4104   <b>node</b> <i></i>
4105)
4106</pre>
4107<dd> Returns the value of a constant node. If <code>node</code> is an internal node, the result is unpredictable.
4108<p>
4109
4110<dd> <b>Side Effects</b> none
4111<p>
4112
4113<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_T">Cudd_T</a>
4114<a href="cuddAllDet.html#Cudd_E">Cudd_E</a>
4115</code>
4116
4117<dt><pre>
4118DdNode * <i></i>
4119<a name="Cudd_Xeqy"><b>Cudd_Xeqy</b></a>(
4120  DdManager * <b>dd</b>, <i>DD manager</i>
4121  int  <b>N</b>, <i>number of x and y variables</i>
4122  DdNode ** <b>x</b>, <i>array of x variables</i>
4123  DdNode ** <b>y</b> <i>array of y variables</i>
4124)
4125</pre>
4126<dd> This function generates a BDD for the function x==y. Both x and y are N-bit numbers, x[0] x[1] ... x[N-1] and y[0] y[1] ... y[N-1], with 0 the most significant bit. The BDD is built bottom-up. It has 3*N-1 internal nodes, if the variables are ordered as follows: x[0] y[0] x[1] y[1] ... x[N-1] y[N-1].
4127<p>
4128
4129<dd> <b>Side Effects</b> None
4130<p>
4131
4132<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_addXeqy">Cudd_addXeqy</a>
4133</code>
4134
4135<dt><pre>
4136DdNode * <i></i>
4137<a name="Cudd_Xgty"><b>Cudd_Xgty</b></a>(
4138  DdManager * <b>dd</b>, <i>DD manager</i>
4139  int  <b>N</b>, <i>number of x and y variables</i>
4140  DdNode ** <b>z</b>, <i>array of z variables: unused</i>
4141  DdNode ** <b>x</b>, <i>array of x variables</i>
4142  DdNode ** <b>y</b> <i>array of y variables</i>
4143)
4144</pre>
4145<dd> This function generates a BDD for the function x &gt; y. Both x and y are N-bit numbers, x[0] x[1] ... x[N-1] and y[0] y[1] ... y[N-1], with 0 the most significant bit. The BDD is built bottom-up. It has 3*N-1 internal nodes, if the variables are ordered as follows: x[0] y[0] x[1] y[1] ... x[N-1] y[N-1]. Argument z is not used by Cudd_Xgty: it is included to make it call-compatible to Cudd_Dxygtdxz and Cudd_Dxygtdyz.
4146<p>
4147
4148<dd> <b>Side Effects</b> None
4149<p>
4150
4151<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_PrioritySelect">Cudd_PrioritySelect</a>
4152<a href="cuddAllDet.html#Cudd_Dxygtdxz">Cudd_Dxygtdxz</a>
4153<a href="cuddAllDet.html#Cudd_Dxygtdyz">Cudd_Dxygtdyz</a>
4154</code>
4155
4156<dt><pre>
4157DdNode * <i></i>
4158<a name="Cudd_addAgreement"><b>Cudd_addAgreement</b></a>(
4159  DdManager * <b>dd</b>, <i></i>
4160  DdNode ** <b>f</b>, <i></i>
4161  DdNode ** <b>g</b> <i></i>
4162)
4163</pre>
4164<dd> Returns NULL if not a terminal case; f op g otherwise, where f op g is f if f==g; background if f!=g.
4165<p>
4166
4167<dd> <b>Side Effects</b> None
4168<p>
4169
4170<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_addApply">Cudd_addApply</a>
4171</code>
4172
4173<dt><pre>
4174DdNode * <i></i>
4175<a name="Cudd_addApply"><b>Cudd_addApply</b></a>(
4176  DdManager * <b>dd</b>, <i></i>
4177  DD_AOP  <b>op</b>, <i></i>
4178  DdNode * <b>f</b>, <i></i>
4179  DdNode * <b>g</b> <i></i>
4180)
4181</pre>
4182<dd> Applies op to the corresponding discriminants of f and g. Returns a pointer to the result if succssful; NULL otherwise.
4183<p>
4184
4185<dd> <b>Side Effects</b> None
4186<p>
4187
4188<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_addMonadicApply">Cudd_addMonadicApply</a>
4189<a href="cuddAllDet.html#Cudd_addPlus">Cudd_addPlus</a>
4190<a href="cuddAllDet.html#Cudd_addTimes">Cudd_addTimes</a>
4191<a href="cuddAllDet.html#Cudd_addThreshold">Cudd_addThreshold</a>
4192<a href="cuddAllDet.html#Cudd_addSetNZ">Cudd_addSetNZ</a>
4193<a href="cuddAllDet.html#Cudd_addDivide">Cudd_addDivide</a>
4194<a href="cuddAllDet.html#Cudd_addMinus">Cudd_addMinus</a>
4195<a href="cuddAllDet.html#Cudd_addMinimum">Cudd_addMinimum</a>
4196<a href="cuddAllDet.html#Cudd_addMaximum">Cudd_addMaximum</a>
4197<a href="cuddAllDet.html#Cudd_addOneZeroMaximum">Cudd_addOneZeroMaximum</a>
4198<a href="cuddAllDet.html#Cudd_addDiff">Cudd_addDiff</a>
4199<a href="cuddAllDet.html#Cudd_addAgreement">Cudd_addAgreement</a>
4200<a href="cuddAllDet.html#Cudd_addOr">Cudd_addOr</a>
4201<a href="cuddAllDet.html#Cudd_addNand">Cudd_addNand</a>
4202<a href="cuddAllDet.html#Cudd_addNor">Cudd_addNor</a>
4203<a href="cuddAllDet.html#Cudd_addXor">Cudd_addXor</a>
4204<a href="cuddAllDet.html#Cudd_addXnor">Cudd_addXnor</a>
4205</code>
4206
4207<dt><pre>
4208DdNode * <i></i>
4209<a name="Cudd_addBddInterval"><b>Cudd_addBddInterval</b></a>(
4210  DdManager * <b>dd</b>, <i></i>
4211  DdNode * <b>f</b>, <i></i>
4212  CUDD_VALUE_TYPE  <b>lower</b>, <i></i>
4213  CUDD_VALUE_TYPE  <b>upper</b> <i></i>
4214)
4215</pre>
4216<dd> Converts an ADD to a BDD by replacing all discriminants greater than or equal to lower and less than or equal to upper with 1, and all other discriminants with 0. Returns a pointer to the resulting BDD if successful; NULL otherwise.
4217<p>
4218
4219<dd> <b>Side Effects</b> None
4220<p>
4221
4222<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_addBddThreshold">Cudd_addBddThreshold</a>
4223<a href="cuddAllDet.html#Cudd_addBddStrictThreshold">Cudd_addBddStrictThreshold</a>
4224<a href="cuddAllDet.html#Cudd_addBddPattern">Cudd_addBddPattern</a>
4225<a href="cuddAllDet.html#Cudd_BddToAdd">Cudd_BddToAdd</a>
4226</code>
4227
4228<dt><pre>
4229DdNode * <i></i>
4230<a name="Cudd_addBddIthBit"><b>Cudd_addBddIthBit</b></a>(
4231  DdManager * <b>dd</b>, <i></i>
4232  DdNode * <b>f</b>, <i></i>
4233  int  <b>bit</b> <i></i>
4234)
4235</pre>
4236<dd> Converts an ADD to a BDD by replacing all discriminants whose i-th bit is equal to 1 with 1, and all other discriminants with 0. The i-th bit refers to the integer representation of the leaf value. If the value is has a fractional part, it is ignored. Repeated calls to this procedure allow one to transform an integer-valued ADD into an array of BDDs, one for each bit of the leaf values. Returns a pointer to the resulting BDD if successful; NULL otherwise.
4237<p>
4238
4239<dd> <b>Side Effects</b> None
4240<p>
4241
4242<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_addBddInterval">Cudd_addBddInterval</a>
4243<a href="cuddAllDet.html#Cudd_addBddPattern">Cudd_addBddPattern</a>
4244<a href="cuddAllDet.html#Cudd_BddToAdd">Cudd_BddToAdd</a>
4245</code>
4246
4247<dt><pre>
4248DdNode * <i></i>
4249<a name="Cudd_addBddPattern"><b>Cudd_addBddPattern</b></a>(
4250  DdManager * <b>dd</b>, <i></i>
4251  DdNode * <b>f</b> <i></i>
4252)
4253</pre>
4254<dd> Converts an ADD to a BDD by replacing all discriminants different from 0 with 1. Returns a pointer to the resulting BDD if successful; NULL otherwise.
4255<p>
4256
4257<dd> <b>Side Effects</b> None
4258<p>
4259
4260<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_BddToAdd">Cudd_BddToAdd</a>
4261<a href="cuddAllDet.html#Cudd_addBddThreshold">Cudd_addBddThreshold</a>
4262<a href="cuddAllDet.html#Cudd_addBddInterval">Cudd_addBddInterval</a>
4263<a href="cuddAllDet.html#Cudd_addBddStrictThreshold">Cudd_addBddStrictThreshold</a>
4264</code>
4265
4266<dt><pre>
4267DdNode * <i></i>
4268<a name="Cudd_addBddStrictThreshold"><b>Cudd_addBddStrictThreshold</b></a>(
4269  DdManager * <b>dd</b>, <i></i>
4270  DdNode * <b>f</b>, <i></i>
4271  CUDD_VALUE_TYPE  <b>value</b> <i></i>
4272)
4273</pre>
4274<dd> Converts an ADD to a BDD by replacing all discriminants STRICTLY greater than value with 1, and all other discriminants with 0. Returns a pointer to the resulting BDD if successful; NULL otherwise.
4275<p>
4276
4277<dd> <b>Side Effects</b> None
4278<p>
4279
4280<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_addBddInterval">Cudd_addBddInterval</a>
4281<a href="cuddAllDet.html#Cudd_addBddPattern">Cudd_addBddPattern</a>
4282<a href="cuddAllDet.html#Cudd_BddToAdd">Cudd_BddToAdd</a>
4283<a href="cuddAllDet.html#Cudd_addBddThreshold">Cudd_addBddThreshold</a>
4284</code>
4285
4286<dt><pre>
4287DdNode * <i></i>
4288<a name="Cudd_addBddThreshold"><b>Cudd_addBddThreshold</b></a>(
4289  DdManager * <b>dd</b>, <i></i>
4290  DdNode * <b>f</b>, <i></i>
4291  CUDD_VALUE_TYPE  <b>value</b> <i></i>
4292)
4293</pre>
4294<dd> Converts an ADD to a BDD by replacing all discriminants greater than or equal to value with 1, and all other discriminants with 0. Returns a pointer to the resulting BDD if successful; NULL otherwise.
4295<p>
4296
4297<dd> <b>Side Effects</b> None
4298<p>
4299
4300<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_addBddInterval">Cudd_addBddInterval</a>
4301<a href="cuddAllDet.html#Cudd_addBddPattern">Cudd_addBddPattern</a>
4302<a href="cuddAllDet.html#Cudd_BddToAdd">Cudd_BddToAdd</a>
4303<a href="cuddAllDet.html#Cudd_addBddStrictThreshold">Cudd_addBddStrictThreshold</a>
4304</code>
4305
4306<dt><pre>
4307DdNode * <i></i>
4308<a name="Cudd_addCmpl"><b>Cudd_addCmpl</b></a>(
4309  DdManager * <b>dd</b>, <i></i>
4310  DdNode * <b>f</b> <i></i>
4311)
4312</pre>
4313<dd> Computes the complement of an ADD a la C language: The complement of 0 is 1 and the complement of everything else is 0. Returns a pointer to the resulting ADD if successful; NULL otherwise.
4314<p>
4315
4316<dd> <b>Side Effects</b> None
4317<p>
4318
4319<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_addNegate">Cudd_addNegate</a>
4320</code>
4321
4322<dt><pre>
4323DdNode * <i></i>
4324<a name="Cudd_addCompose"><b>Cudd_addCompose</b></a>(
4325  DdManager * <b>dd</b>, <i></i>
4326  DdNode * <b>f</b>, <i></i>
4327  DdNode * <b>g</b>, <i></i>
4328  int  <b>v</b> <i></i>
4329)
4330</pre>
4331<dd> Substitutes g for x_v in the ADD for f. v is the index of the variable to be substituted. g must be a 0-1 ADD. Cudd_bddCompose passes the corresponding projection function to the recursive procedure, so that the cache may be used. Returns the composed ADD if successful; NULL otherwise.
4332<p>
4333
4334<dd> <b>Side Effects</b> None
4335<p>
4336
4337<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_bddCompose">Cudd_bddCompose</a>
4338</code>
4339
4340<dt><pre>
4341DdNode * <i></i>
4342<a name="Cudd_addComputeCube"><b>Cudd_addComputeCube</b></a>(
4343  DdManager * <b>dd</b>, <i></i>
4344  DdNode ** <b>vars</b>, <i></i>
4345  int * <b>phase</b>, <i></i>
4346  int  <b>n</b> <i></i>
4347)
4348</pre>
4349<dd> Computes the cube of an array of ADD variables. If non-null, the phase argument indicates which literal of each variable should appear in the cube. If phase[i] is nonzero, then the positive literal is used. If phase is NULL, the cube is positive unate. Returns a pointer to the result if successful; NULL otherwise.
4350<p>
4351
4352<dd> <b>Side Effects</b> none
4353<p>
4354
4355<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_bddComputeCube">Cudd_bddComputeCube</a>
4356</code>
4357
4358<dt><pre>
4359DdNode * <i></i>
4360<a name="Cudd_addConstrain"><b>Cudd_addConstrain</b></a>(
4361  DdManager * <b>dd</b>, <i></i>
4362  DdNode * <b>f</b>, <i></i>
4363  DdNode * <b>c</b> <i></i>
4364)
4365</pre>
4366<dd> Computes f constrain c (f @ c), for f an ADD and c a 0-1 ADD. List of special cases: <ul> <li> F @ 0 = 0 <li> F @ 1 = F <li> 0 @ c = 0 <li> 1 @ c = 1 <li> F @ F = 1 </ul> Returns a pointer to the result if successful; NULL otherwise.
4367<p>
4368
4369<dd> <b>Side Effects</b> None
4370<p>
4371
4372<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_bddConstrain">Cudd_bddConstrain</a>
4373</code>
4374
4375<dt><pre>
4376DdNode * <i></i>
4377<a name="Cudd_addConst"><b>Cudd_addConst</b></a>(
4378  DdManager * <b>dd</b>, <i></i>
4379  CUDD_VALUE_TYPE  <b>c</b> <i></i>
4380)
4381</pre>
4382<dd> Retrieves the ADD for constant c if it already exists, or creates a new ADD. Returns a pointer to the ADD if successful; NULL otherwise.
4383<p>
4384
4385<dd> <b>Side Effects</b> None
4386<p>
4387
4388<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_addNewVar">Cudd_addNewVar</a>
4389<a href="cuddAllDet.html#Cudd_addIthVar">Cudd_addIthVar</a>
4390</code>
4391
4392<dt><pre>
4393DdNode * <i></i>
4394<a name="Cudd_addDiff"><b>Cudd_addDiff</b></a>(
4395  DdManager * <b>dd</b>, <i></i>
4396  DdNode ** <b>f</b>, <i></i>
4397  DdNode ** <b>g</b> <i></i>
4398)
4399</pre>
4400<dd> Returns NULL if not a terminal case; f op g otherwise, where f op g is plusinfinity if f=g; min(f,g) if f!=g.
4401<p>
4402
4403<dd> <b>Side Effects</b> None
4404<p>
4405
4406<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_addApply">Cudd_addApply</a>
4407</code>
4408
4409<dt><pre>
4410DdNode * <i></i>
4411<a name="Cudd_addDivide"><b>Cudd_addDivide</b></a>(
4412  DdManager * <b>dd</b>, <i></i>
4413  DdNode ** <b>f</b>, <i></i>
4414  DdNode ** <b>g</b> <i></i>
4415)
4416</pre>
4417<dd> Integer and floating point division. Returns NULL if not a terminal case; f / g otherwise.
4418<p>
4419
4420<dd> <b>Side Effects</b> None
4421<p>
4422
4423<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_addApply">Cudd_addApply</a>
4424</code>
4425
4426<dt><pre>
4427DdNode * <i></i>
4428<a name="Cudd_addEvalConst"><b>Cudd_addEvalConst</b></a>(
4429  DdManager * <b>dd</b>, <i></i>
4430  DdNode * <b>f</b>, <i></i>
4431  DdNode * <b>g</b> <i></i>
4432)
4433</pre>
4434<dd> Checks whether ADD g is constant whenever ADD f is 1. f must be a 0-1 ADD. Returns a pointer to the resulting ADD (which may or may not be constant) or DD_NON_CONSTANT. If f is identically 0, the check is assumed to be successful, and the background value is returned. No new nodes are created.
4435<p>
4436
4437<dd> <b>Side Effects</b> None
4438<p>
4439
4440<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_addIteConstant">Cudd_addIteConstant</a>
4441<a href="cuddAllDet.html#Cudd_addLeq">Cudd_addLeq</a>
4442</code>
4443
4444<dt><pre>
4445DdNode * <i></i>
4446<a name="Cudd_addExistAbstract"><b>Cudd_addExistAbstract</b></a>(
4447  DdManager * <b>manager</b>, <i></i>
4448  DdNode * <b>f</b>, <i></i>
4449  DdNode * <b>cube</b> <i></i>
4450)
4451</pre>
4452<dd> Abstracts all the variables in cube from f by summing over all possible values taken by the variables. Returns the abstracted ADD.
4453<p>
4454
4455<dd> <b>Side Effects</b> None
4456<p>
4457
4458<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_addUnivAbstract">Cudd_addUnivAbstract</a>
4459<a href="cuddAllDet.html#Cudd_bddExistAbstract">Cudd_bddExistAbstract</a>
4460<a href="cuddAllDet.html#Cudd_addOrAbstract">Cudd_addOrAbstract</a>
4461</code>
4462
4463<dt><pre>
4464DdNode * <i></i>
4465<a name="Cudd_addFindMax"><b>Cudd_addFindMax</b></a>(
4466  DdManager * <b>dd</b>, <i></i>
4467  DdNode * <b>f</b> <i></i>
4468)
4469</pre>
4470<dd> Returns a pointer to a constant ADD.
4471<p>
4472
4473<dd> <b>Side Effects</b> None
4474<p>
4475
4476<dt><pre>
4477DdNode * <i></i>
4478<a name="Cudd_addFindMin"><b>Cudd_addFindMin</b></a>(
4479  DdManager * <b>dd</b>, <i></i>
4480  DdNode * <b>f</b> <i></i>
4481)
4482</pre>
4483<dd> Returns a pointer to a constant ADD.
4484<p>
4485
4486<dd> <b>Side Effects</b> None
4487<p>
4488
4489<dt><pre>
4490DdNode * <i></i>
4491<a name="Cudd_addGeneralVectorCompose"><b>Cudd_addGeneralVectorCompose</b></a>(
4492  DdManager * <b>dd</b>, <i></i>
4493  DdNode * <b>f</b>, <i></i>
4494  DdNode ** <b>vectorOn</b>, <i></i>
4495  DdNode ** <b>vectorOff</b> <i></i>
4496)
4497</pre>
4498<dd> Given a vector of ADDs, creates a new ADD by substituting the ADDs for the variables of the ADD f. vectorOn contains ADDs to be substituted for the x_v and vectorOff the ADDs to be substituted for x_v'. There should be an entry in vector for each variable in the manager. If no substitution is sought for a given variable, the corresponding projection function should be specified in the vector. This function implements simultaneous composition. Returns a pointer to the resulting ADD if successful; NULL otherwise.
4499<p>
4500
4501<dd> <b>Side Effects</b> None
4502<p>
4503
4504<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_addVectorCompose">Cudd_addVectorCompose</a>
4505<a href="cuddAllDet.html#Cudd_addNonSimCompose">Cudd_addNonSimCompose</a>
4506<a href="cuddAllDet.html#Cudd_addPermute">Cudd_addPermute</a>
4507<a href="cuddAllDet.html#Cudd_addCompose">Cudd_addCompose</a>
4508<a href="cuddAllDet.html#Cudd_bddVectorCompose">Cudd_bddVectorCompose</a>
4509</code>
4510
4511<dt><pre>
4512DdNode * <i></i>
4513<a name="Cudd_addHamming"><b>Cudd_addHamming</b></a>(
4514  DdManager * <b>dd</b>, <i></i>
4515  DdNode ** <b>xVars</b>, <i></i>
4516  DdNode ** <b>yVars</b>, <i></i>
4517  int  <b>nVars</b> <i></i>
4518)
4519</pre>
4520<dd> Computes the Hamming distance ADD. Returns an ADD that gives the Hamming distance between its two arguments if successful; NULL otherwise. The two vectors xVars and yVars identify the variables that form the two arguments.
4521<p>
4522
4523<dd> <b>Side Effects</b> None
4524<p>
4525
4526<dt><pre>
4527int <i></i>
4528<a name="Cudd_addHarwell"><b>Cudd_addHarwell</b></a>(
4529  FILE * <b>fp</b>, <i>pointer to the input file</i>
4530  DdManager * <b>dd</b>, <i>DD manager</i>
4531  DdNode ** <b>E</b>, <i>characteristic function of the graph</i>
4532  DdNode *** <b>x</b>, <i>array of row variables</i>
4533  DdNode *** <b>y</b>, <i>array of column variables</i>
4534  DdNode *** <b>xn</b>, <i>array of complemented row variables</i>
4535  DdNode *** <b>yn_</b>, <i>array of complemented column variables</i>
4536  int * <b>nx</b>, <i>number or row variables</i>
4537  int * <b>ny</b>, <i>number or column variables</i>
4538  int * <b>m</b>, <i>number of rows</i>
4539  int * <b>n</b>, <i>number of columns</i>
4540  int  <b>bx</b>, <i>first index of row variables</i>
4541  int  <b>sx</b>, <i>step of row variables</i>
4542  int  <b>by</b>, <i>first index of column variables</i>
4543  int  <b>sy</b>, <i>step of column variables</i>
4544  int  <b>pr</b> <i>verbosity level</i>
4545)
4546</pre>
4547<dd> Reads in a matrix in the format of the Harwell-Boeing benchmark suite. The variables are ordered as follows: <blockquote> x[0] y[0] x[1] y[1] ... </blockquote> 0 is the most significant bit. On input, nx and ny hold the numbers of row and column variables already in existence. On output, they hold the numbers of row and column variables actually used by the matrix. m and n are set to the numbers of rows and columns of the matrix. Their values on input are immaterial. Returns 1 on success; 0 otherwise. The ADD for the sparse matrix is returned in E, and its reference count is > 0.
4548<p>
4549
4550<dd> <b>Side Effects</b> None
4551<p>
4552
4553<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_addRead">Cudd_addRead</a>
4554<a href="cuddAllDet.html#Cudd_bddRead">Cudd_bddRead</a>
4555</code>
4556
4557<dt><pre>
4558DdNode * <i></i>
4559<a name="Cudd_addIteConstant"><b>Cudd_addIteConstant</b></a>(
4560  DdManager * <b>dd</b>, <i></i>
4561  DdNode * <b>f</b>, <i></i>
4562  DdNode * <b>g</b>, <i></i>
4563  DdNode * <b>h</b> <i></i>
4564)
4565</pre>
4566<dd> Implements ITEconstant for ADDs. f must be a 0-1 ADD. Returns a pointer to the resulting ADD (which may or may not be constant) or DD_NON_CONSTANT. No new nodes are created. This function can be used, for instance, to check that g has a constant value (specified by h) whenever f is 1. If the constant value is unknown, then one should use Cudd_addEvalConst.
4567<p>
4568
4569<dd> <b>Side Effects</b> None
4570<p>
4571
4572<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_addIte">Cudd_addIte</a>
4573<a href="cuddAllDet.html#Cudd_addEvalConst">Cudd_addEvalConst</a>
4574<a href="cuddAllDet.html#Cudd_bddIteConstant">Cudd_bddIteConstant</a>
4575</code>
4576
4577<dt><pre>
4578DdNode * <i></i>
4579<a name="Cudd_addIte"><b>Cudd_addIte</b></a>(
4580  DdManager * <b>dd</b>, <i></i>
4581  DdNode * <b>f</b>, <i></i>
4582  DdNode * <b>g</b>, <i></i>
4583  DdNode * <b>h</b> <i></i>
4584)
4585</pre>
4586<dd> Implements ITE(f,g,h). This procedure assumes that f is a 0-1 ADD. Returns a pointer to the resulting ADD if successful; NULL otherwise.
4587<p>
4588
4589<dd> <b>Side Effects</b> None
4590<p>
4591
4592<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_bddIte">Cudd_bddIte</a>
4593<a href="cuddAllDet.html#Cudd_addIteConstant">Cudd_addIteConstant</a>
4594<a href="cuddAllDet.html#Cudd_addApply">Cudd_addApply</a>
4595</code>
4596
4597<dt><pre>
4598DdNode * <i></i>
4599<a name="Cudd_addIthBit"><b>Cudd_addIthBit</b></a>(
4600  DdManager * <b>dd</b>, <i></i>
4601  DdNode * <b>f</b>, <i></i>
4602  int  <b>bit</b> <i></i>
4603)
4604</pre>
4605<dd> Produces an ADD from another ADD by replacing all discriminants whose i-th bit is equal to 1 with 1, and all other discriminants with 0. The i-th bit refers to the integer representation of the leaf value. If the value is has a fractional part, it is ignored. Repeated calls to this procedure allow one to transform an integer-valued ADD into an array of ADDs, one for each bit of the leaf values. Returns a pointer to the resulting ADD if successful; NULL otherwise.
4606<p>
4607
4608<dd> <b>Side Effects</b> None
4609<p>
4610
4611<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_addBddIthBit">Cudd_addBddIthBit</a>
4612</code>
4613
4614<dt><pre>
4615DdNode * <i></i>
4616<a name="Cudd_addIthVar"><b>Cudd_addIthVar</b></a>(
4617  DdManager * <b>dd</b>, <i></i>
4618  int  <b>i</b> <i></i>
4619)
4620</pre>
4621<dd> Retrieves the ADD variable with index i if it already exists, or creates a new ADD variable. Returns a pointer to the variable if successful; NULL otherwise. An ADD variable differs from a BDD variable because it points to the arithmetic zero, instead of having a complement pointer to 1.
4622<p>
4623
4624<dd> <b>Side Effects</b> None
4625<p>
4626
4627<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_addNewVar">Cudd_addNewVar</a>
4628<a href="cuddAllDet.html#Cudd_bddIthVar">Cudd_bddIthVar</a>
4629<a href="cuddAllDet.html#Cudd_addConst">Cudd_addConst</a>
4630<a href="cuddAllDet.html#Cudd_addNewVarAtLevel">Cudd_addNewVarAtLevel</a>
4631</code>
4632
4633<dt><pre>
4634int <i></i>
4635<a name="Cudd_addLeq"><b>Cudd_addLeq</b></a>(
4636  DdManager * <b>dd</b>, <i></i>
4637  DdNode * <b>f</b>, <i></i>
4638  DdNode * <b>g</b> <i></i>
4639)
4640</pre>
4641<dd> Returns 1 if f is less than or equal to g; 0 otherwise. No new nodes are created. This procedure works for arbitrary ADDs. For 0-1 ADDs Cudd_addEvalConst is more efficient.
4642<p>
4643
4644<dd> <b>Side Effects</b> None
4645<p>
4646
4647<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_addIteConstant">Cudd_addIteConstant</a>
4648<a href="cuddAllDet.html#Cudd_addEvalConst">Cudd_addEvalConst</a>
4649<a href="cuddAllDet.html#Cudd_bddLeq">Cudd_bddLeq</a>
4650</code>
4651
4652<dt><pre>
4653DdNode * <i></i>
4654<a name="Cudd_addLog"><b>Cudd_addLog</b></a>(
4655  DdManager * <b>dd</b>, <i></i>
4656  DdNode * <b>f</b> <i></i>
4657)
4658</pre>
4659<dd> Natural logarithm of an ADDs. Returns NULL if not a terminal case; log(f) otherwise. The discriminants of f must be positive double's.
4660<p>
4661
4662<dd> <b>Side Effects</b> None
4663<p>
4664
4665<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_addMonadicApply">Cudd_addMonadicApply</a>
4666</code>
4667
4668<dt><pre>
4669DdNode * <i></i>
4670<a name="Cudd_addMatrixMultiply"><b>Cudd_addMatrixMultiply</b></a>(
4671  DdManager * <b>dd</b>, <i></i>
4672  DdNode * <b>A</b>, <i></i>
4673  DdNode * <b>B</b>, <i></i>
4674  DdNode ** <b>z</b>, <i></i>
4675  int  <b>nz</b> <i></i>
4676)
4677</pre>
4678<dd> Calculates the product of two matrices, A and B, represented as ADDs. This procedure implements the quasiring multiplication algorithm. A is assumed to depend on variables x (rows) and z (columns). B is assumed to depend on variables z (rows) and y (columns). The product of A and B then depends on x (rows) and y (columns). Only the z variables have to be explicitly identified; they are the "summation" variables. Returns a pointer to the result if successful; NULL otherwise.
4679<p>
4680
4681<dd> <b>Side Effects</b> None
4682<p>
4683
4684<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_addTimesPlus">Cudd_addTimesPlus</a>
4685<a href="cuddAllDet.html#Cudd_addTriangle">Cudd_addTriangle</a>
4686<a href="cuddAllDet.html#Cudd_bddAndAbstract">Cudd_bddAndAbstract</a>
4687</code>
4688
4689<dt><pre>
4690DdNode * <i></i>
4691<a name="Cudd_addMaximum"><b>Cudd_addMaximum</b></a>(
4692  DdManager * <b>dd</b>, <i></i>
4693  DdNode ** <b>f</b>, <i></i>
4694  DdNode ** <b>g</b> <i></i>
4695)
4696</pre>
4697<dd> Integer and floating point max for Cudd_addApply. Returns NULL if not a terminal case; max(f,g) otherwise.
4698<p>
4699
4700<dd> <b>Side Effects</b> None
4701<p>
4702
4703<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_addApply">Cudd_addApply</a>
4704</code>
4705
4706<dt><pre>
4707DdNode * <i></i>
4708<a name="Cudd_addMinimum"><b>Cudd_addMinimum</b></a>(
4709  DdManager * <b>dd</b>, <i></i>
4710  DdNode ** <b>f</b>, <i></i>
4711  DdNode ** <b>g</b> <i></i>
4712)
4713</pre>
4714<dd> Integer and floating point min for Cudd_addApply. Returns NULL if not a terminal case; min(f,g) otherwise.
4715<p>
4716
4717<dd> <b>Side Effects</b> None
4718<p>
4719
4720<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_addApply">Cudd_addApply</a>
4721</code>
4722
4723<dt><pre>
4724DdNode * <i></i>
4725<a name="Cudd_addMinus"><b>Cudd_addMinus</b></a>(
4726  DdManager * <b>dd</b>, <i></i>
4727  DdNode ** <b>f</b>, <i></i>
4728  DdNode ** <b>g</b> <i></i>
4729)
4730</pre>
4731<dd> Integer and floating point subtraction. Returns NULL if not a terminal case; f - g otherwise.
4732<p>
4733
4734<dd> <b>Side Effects</b> None
4735<p>
4736
4737<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_addApply">Cudd_addApply</a>
4738</code>
4739
4740<dt><pre>
4741DdNode * <i></i>
4742<a name="Cudd_addMonadicApply"><b>Cudd_addMonadicApply</b></a>(
4743  DdManager * <b>dd</b>, <i></i>
4744  DD_MAOP  <b>op</b>, <i></i>
4745  DdNode * <b>f</b> <i></i>
4746)
4747</pre>
4748<dd> Applies op to the discriminants of f. Returns a pointer to the result if succssful; NULL otherwise.
4749<p>
4750
4751<dd> <b>Side Effects</b> None
4752<p>
4753
4754<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_addApply">Cudd_addApply</a>
4755<a href="cuddAllDet.html#Cudd_addLog">Cudd_addLog</a>
4756</code>
4757
4758<dt><pre>
4759DdNode * <i></i>
4760<a name="Cudd_addNand"><b>Cudd_addNand</b></a>(
4761  DdManager * <b>dd</b>, <i></i>
4762  DdNode ** <b>f</b>, <i></i>
4763  DdNode ** <b>g</b> <i></i>
4764)
4765</pre>
4766<dd> NAND of two 0-1 ADDs. Returns NULL if not a terminal case; f NAND g otherwise.
4767<p>
4768
4769<dd> <b>Side Effects</b> None
4770<p>
4771
4772<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_addApply">Cudd_addApply</a>
4773</code>
4774
4775<dt><pre>
4776DdNode * <i></i>
4777<a name="Cudd_addNegate"><b>Cudd_addNegate</b></a>(
4778  DdManager * <b>dd</b>, <i></i>
4779  DdNode * <b>f</b> <i></i>
4780)
4781</pre>
4782<dd> Computes the additive inverse of an ADD. Returns a pointer to the result if successful; NULL otherwise.
4783<p>
4784
4785<dd> <b>Side Effects</b> None
4786<p>
4787
4788<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_addCmpl">Cudd_addCmpl</a>
4789</code>
4790
4791<dt><pre>
4792DdNode * <i></i>
4793<a name="Cudd_addNewVarAtLevel"><b>Cudd_addNewVarAtLevel</b></a>(
4794  DdManager * <b>dd</b>, <i></i>
4795  int  <b>level</b> <i></i>
4796)
4797</pre>
4798<dd> Creates a new ADD variable. The new variable has an index equal to the largest previous index plus 1 and is positioned at the specified level in the order. Returns a pointer to the new variable if successful; NULL otherwise.
4799<p>
4800
4801<dd> <b>Side Effects</b> None
4802<p>
4803
4804<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_addNewVar">Cudd_addNewVar</a>
4805<a href="cuddAllDet.html#Cudd_addIthVar">Cudd_addIthVar</a>
4806<a href="cuddAllDet.html#Cudd_bddNewVarAtLevel">Cudd_bddNewVarAtLevel</a>
4807</code>
4808
4809<dt><pre>
4810DdNode * <i></i>
4811<a name="Cudd_addNewVar"><b>Cudd_addNewVar</b></a>(
4812  DdManager * <b>dd</b> <i></i>
4813)
4814</pre>
4815<dd> Creates a new ADD variable. The new variable has an index equal to the largest previous index plus 1. Returns a pointer to the new variable if successful; NULL otherwise. An ADD variable differs from a BDD variable because it points to the arithmetic zero, instead of having a complement pointer to 1.
4816<p>
4817
4818<dd> <b>Side Effects</b> None
4819<p>
4820
4821<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_bddNewVar">Cudd_bddNewVar</a>
4822<a href="cuddAllDet.html#Cudd_addIthVar">Cudd_addIthVar</a>
4823<a href="cuddAllDet.html#Cudd_addConst">Cudd_addConst</a>
4824<a href="cuddAllDet.html#Cudd_addNewVarAtLevel">Cudd_addNewVarAtLevel</a>
4825</code>
4826
4827<dt><pre>
4828DdNode * <i></i>
4829<a name="Cudd_addNonSimCompose"><b>Cudd_addNonSimCompose</b></a>(
4830  DdManager * <b>dd</b>, <i></i>
4831  DdNode * <b>f</b>, <i></i>
4832  DdNode ** <b>vector</b> <i></i>
4833)
4834</pre>
4835<dd> Given a vector of 0-1 ADDs, creates a new ADD by substituting the 0-1 ADDs for the variables of the ADD f. There should be an entry in vector for each variable in the manager. This function implements non-simultaneous composition. If any of the functions being composed depends on any of the variables being substituted, then the result depends on the order of composition, which in turn depends on the variable order: The variables farther from the roots in the order are substituted first. Returns a pointer to the resulting ADD if successful; NULL otherwise.
4836<p>
4837
4838<dd> <b>Side Effects</b> None
4839<p>
4840
4841<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_addVectorCompose">Cudd_addVectorCompose</a>
4842<a href="cuddAllDet.html#Cudd_addPermute">Cudd_addPermute</a>
4843<a href="cuddAllDet.html#Cudd_addCompose">Cudd_addCompose</a>
4844</code>
4845
4846<dt><pre>
4847DdNode * <i></i>
4848<a name="Cudd_addNor"><b>Cudd_addNor</b></a>(
4849  DdManager * <b>dd</b>, <i></i>
4850  DdNode ** <b>f</b>, <i></i>
4851  DdNode ** <b>g</b> <i></i>
4852)
4853</pre>
4854<dd> NOR of two 0-1 ADDs. Returns NULL if not a terminal case; f NOR g otherwise.
4855<p>
4856
4857<dd> <b>Side Effects</b> None
4858<p>
4859
4860<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_addApply">Cudd_addApply</a>
4861</code>
4862
4863<dt><pre>
4864DdNode * <i></i>
4865<a name="Cudd_addOneZeroMaximum"><b>Cudd_addOneZeroMaximum</b></a>(
4866  DdManager * <b>dd</b>, <i></i>
4867  DdNode ** <b>f</b>, <i></i>
4868  DdNode ** <b>g</b> <i></i>
4869)
4870</pre>
4871<dd> Returns 1 if f &gt; g and 0 otherwise. Used in conjunction with Cudd_addApply. Returns NULL if not a terminal case.
4872<p>
4873
4874<dd> <b>Side Effects</b> None
4875<p>
4876
4877<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_addApply">Cudd_addApply</a>
4878</code>
4879
4880<dt><pre>
4881DdNode * <i></i>
4882<a name="Cudd_addOrAbstract"><b>Cudd_addOrAbstract</b></a>(
4883  DdManager * <b>manager</b>, <i></i>
4884  DdNode * <b>f</b>, <i></i>
4885  DdNode * <b>cube</b> <i></i>
4886)
4887</pre>
4888<dd> Abstracts all the variables in cube from the 0-1 ADD f by taking the disjunction over all possible values taken by the variables. Returns the abstracted ADD if successful; NULL otherwise.
4889<p>
4890
4891<dd> <b>Side Effects</b> None
4892<p>
4893
4894<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_addUnivAbstract">Cudd_addUnivAbstract</a>
4895<a href="cuddAllDet.html#Cudd_addExistAbstract">Cudd_addExistAbstract</a>
4896</code>
4897
4898<dt><pre>
4899DdNode * <i></i>
4900<a name="Cudd_addOr"><b>Cudd_addOr</b></a>(
4901  DdManager * <b>dd</b>, <i></i>
4902  DdNode ** <b>f</b>, <i></i>
4903  DdNode ** <b>g</b> <i></i>
4904)
4905</pre>
4906<dd> Disjunction of two 0-1 ADDs. Returns NULL if not a terminal case; f OR g otherwise.
4907<p>
4908
4909<dd> <b>Side Effects</b> None
4910<p>
4911
4912<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_addApply">Cudd_addApply</a>
4913</code>
4914
4915<dt><pre>
4916DdNode * <i></i>
4917<a name="Cudd_addOuterSum"><b>Cudd_addOuterSum</b></a>(
4918  DdManager * <b>dd</b>, <i></i>
4919  DdNode * <b>M</b>, <i></i>
4920  DdNode * <b>r</b>, <i></i>
4921  DdNode * <b>c</b> <i></i>
4922)
4923</pre>
4924<dd> Takes the pointwise minimum of a matrix and the outer sum of two vectors. This procedure is used in the Floyd-Warshall all-pair shortest path algorithm. Returns a pointer to the result if successful; NULL otherwise.
4925<p>
4926
4927<dd> <b>Side Effects</b> None
4928<p>
4929
4930<dt><pre>
4931DdNode * <i></i>
4932<a name="Cudd_addPermute"><b>Cudd_addPermute</b></a>(
4933  DdManager * <b>manager</b>, <i></i>
4934  DdNode * <b>node</b>, <i></i>
4935  int * <b>permut</b> <i></i>
4936)
4937</pre>
4938<dd> Given a permutation in array permut, creates a new ADD with permuted variables. There should be an entry in array permut for each variable in the manager. The i-th entry of permut holds the index of the variable that is to substitute the i-th variable. Returns a pointer to the resulting ADD if successful; NULL otherwise.
4939<p>
4940
4941<dd> <b>Side Effects</b> None
4942<p>
4943
4944<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_bddPermute">Cudd_bddPermute</a>
4945<a href="cuddAllDet.html#Cudd_addSwapVariables">Cudd_addSwapVariables</a>
4946</code>
4947
4948<dt><pre>
4949DdNode * <i></i>
4950<a name="Cudd_addPlus"><b>Cudd_addPlus</b></a>(
4951  DdManager * <b>dd</b>, <i></i>
4952  DdNode ** <b>f</b>, <i></i>
4953  DdNode ** <b>g</b> <i></i>
4954)
4955</pre>
4956<dd> Integer and floating point addition. Returns NULL if not a terminal case; f+g otherwise.
4957<p>
4958
4959<dd> <b>Side Effects</b> None
4960<p>
4961
4962<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_addApply">Cudd_addApply</a>
4963</code>
4964
4965<dt><pre>
4966int <i></i>
4967<a name="Cudd_addRead"><b>Cudd_addRead</b></a>(
4968  FILE * <b>fp</b>, <i>input file pointer</i>
4969  DdManager * <b>dd</b>, <i>DD manager</i>
4970  DdNode ** <b>E</b>, <i>characteristic function of the graph</i>
4971  DdNode *** <b>x</b>, <i>array of row variables</i>
4972  DdNode *** <b>y</b>, <i>array of column variables</i>
4973  DdNode *** <b>xn</b>, <i>array of complemented row variables</i>
4974  DdNode *** <b>yn_</b>, <i>array of complemented column variables</i>
4975  int * <b>nx</b>, <i>number or row variables</i>
4976  int * <b>ny</b>, <i>number or column variables</i>
4977  int * <b>m</b>, <i>number of rows</i>
4978  int * <b>n</b>, <i>number of columns</i>
4979  int  <b>bx</b>, <i>first index of row variables</i>
4980  int  <b>sx</b>, <i>step of row variables</i>
4981  int  <b>by</b>, <i>first index of column variables</i>
4982  int  <b>sy</b> <i>step of column variables</i>
4983)
4984</pre>
4985<dd> Reads in a sparse matrix specified in a simple format. The first line of the input contains the numbers of rows and columns. The remaining lines contain the elements of the matrix, one per line. Given a background value (specified by the background field of the manager), only the values different from it are explicitly listed. Each foreground element is described by two integers, i.e., the row and column number, and a real number, i.e., the value.<p> Cudd_addRead produces an ADD that depends on two sets of variables: x and y. The x variables (x[0] ... x[nx-1]) encode the row index and the y variables (y[0] ... y[ny-1]) encode the column index. x[0] and y[0] are the most significant bits in the indices. The variables may already exist or may be created by the function. The index of x[i] is bx+i*sx, and the index of y[i] is by+i*sy.<p> On input, nx and ny hold the numbers of row and column variables already in existence. On output, they hold the numbers of row and column variables actually used by the matrix. When Cudd_addRead creates the variable arrays, the index of x[i] is bx+i*sx, and the index of y[i] is by+i*sy. When some variables already exist Cudd_addRead expects the indices of the existing x variables to be bx+i*sx, and the indices of the existing y variables to be by+i*sy.<p> m and n are set to the numbers of rows and columns of the matrix. Their values on input are immaterial. The ADD for the sparse matrix is returned in E, and its reference count is > 0. Cudd_addRead returns 1 in case of success; 0 otherwise.
4986<p>
4987
4988<dd> <b>Side Effects</b> nx and ny are set to the numbers of row and column variables. m and n are set to the numbers of rows and columns. x and y are possibly extended to represent the array of row and column variables. Similarly for xn and yn_, which hold on return from Cudd_addRead the complements of the row and column variables.
4989<p>
4990
4991<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_addHarwell">Cudd_addHarwell</a>
4992<a href="cuddAllDet.html#Cudd_bddRead">Cudd_bddRead</a>
4993</code>
4994
4995<dt><pre>
4996DdNode * <i></i>
4997<a name="Cudd_addResidue"><b>Cudd_addResidue</b></a>(
4998  DdManager * <b>dd</b>, <i>manager</i>
4999  int  <b>n</b>, <i>number of bits</i>
5000  int  <b>m</b>, <i>modulus</i>
5001  int  <b>options</b>, <i>options</i>
5002  int  <b>top</b> <i>index of top variable</i>
5003)
5004</pre>
5005<dd> Builds an ADD for the residue modulo m of an n-bit number. The modulus must be at least 2, and the number of bits at least 1. Parameter options specifies whether the MSB should be on top or the LSB; and whther the number whose residue is computed is in two's complement notation or not. The macro CUDD_RESIDUE_DEFAULT specifies LSB on top and unsigned number. The macro CUDD_RESIDUE_MSB specifies MSB on top, and the macro CUDD_RESIDUE_TC specifies two's complement residue. To request MSB on top and two's complement residue simultaneously, one can OR the two macros: CUDD_RESIDUE_MSB | CUDD_RESIDUE_TC. Cudd_addResidue returns a pointer to the resulting ADD if successful; NULL otherwise.
5006<p>
5007
5008<dd> <b>Side Effects</b> None
5009<p>
5010
5011<dt><pre>
5012DdNode * <i></i>
5013<a name="Cudd_addRestrict"><b>Cudd_addRestrict</b></a>(
5014  DdManager * <b>dd</b>, <i></i>
5015  DdNode * <b>f</b>, <i></i>
5016  DdNode * <b>c</b> <i></i>
5017)
5018</pre>
5019<dd> ADD restrict according to Coudert and Madre's algorithm (ICCAD90). Returns the restricted ADD if successful; otherwise NULL. If application of restrict results in an ADD larger than the input ADD, the input ADD is returned.
5020<p>
5021
5022<dd> <b>Side Effects</b> None
5023<p>
5024
5025<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_addConstrain">Cudd_addConstrain</a>
5026<a href="cuddAllDet.html#Cudd_bddRestrict">Cudd_bddRestrict</a>
5027</code>
5028
5029<dt><pre>
5030DdNode * <i></i>
5031<a name="Cudd_addRoundOff"><b>Cudd_addRoundOff</b></a>(
5032  DdManager * <b>dd</b>, <i></i>
5033  DdNode * <b>f</b>, <i></i>
5034  int  <b>N</b> <i></i>
5035)
5036</pre>
5037<dd> Rounds off the discriminants of an ADD. The discriminants are rounded off to N digits after the decimal. Returns a pointer to the result ADD if successful; NULL otherwise.
5038<p>
5039
5040<dd> <b>Side Effects</b> None
5041<p>
5042
5043<dt><pre>
5044DdNode * <i></i>
5045<a name="Cudd_addScalarInverse"><b>Cudd_addScalarInverse</b></a>(
5046  DdManager * <b>dd</b>, <i></i>
5047  DdNode * <b>f</b>, <i></i>
5048  DdNode * <b>epsilon</b> <i></i>
5049)
5050</pre>
5051<dd> Computes an n ADD where the discriminants are the multiplicative inverses of the corresponding discriminants of the argument ADD. Returns a pointer to the resulting ADD in case of success. Returns NULL if any discriminants smaller than epsilon is encountered.
5052<p>
5053
5054<dd> <b>Side Effects</b> None
5055<p>
5056
5057<dt><pre>
5058DdNode * <i></i>
5059<a name="Cudd_addSetNZ"><b>Cudd_addSetNZ</b></a>(
5060  DdManager * <b>dd</b>, <i></i>
5061  DdNode ** <b>f</b>, <i></i>
5062  DdNode ** <b>g</b> <i></i>
5063)
5064</pre>
5065<dd> This operator sets f to the value of g wherever g != 0. Returns NULL if not a terminal case; f op g otherwise.
5066<p>
5067
5068<dd> <b>Side Effects</b> None
5069<p>
5070
5071<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_addApply">Cudd_addApply</a>
5072</code>
5073
5074<dt><pre>
5075DdNode * <i></i>
5076<a name="Cudd_addSwapVariables"><b>Cudd_addSwapVariables</b></a>(
5077  DdManager * <b>dd</b>, <i></i>
5078  DdNode * <b>f</b>, <i></i>
5079  DdNode ** <b>x</b>, <i></i>
5080  DdNode ** <b>y</b>, <i></i>
5081  int  <b>n</b> <i></i>
5082)
5083</pre>
5084<dd> Swaps two sets of variables of the same size (x and y) in the ADD f. The size is given by n. The two sets of variables are assumed to be disjoint. Returns a pointer to the resulting ADD if successful; NULL otherwise.
5085<p>
5086
5087<dd> <b>Side Effects</b> None
5088<p>
5089
5090<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_addPermute">Cudd_addPermute</a>
5091<a href="cuddAllDet.html#Cudd_bddSwapVariables">Cudd_bddSwapVariables</a>
5092</code>
5093
5094<dt><pre>
5095DdNode * <i></i>
5096<a name="Cudd_addThreshold"><b>Cudd_addThreshold</b></a>(
5097  DdManager * <b>dd</b>, <i></i>
5098  DdNode ** <b>f</b>, <i></i>
5099  DdNode ** <b>g</b> <i></i>
5100)
5101</pre>
5102<dd> Threshold operator for Apply (f if f &gt;=g; 0 if f&lt;g). Returns NULL if not a terminal case; f op g otherwise.
5103<p>
5104
5105<dd> <b>Side Effects</b> None
5106<p>
5107
5108<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_addApply">Cudd_addApply</a>
5109</code>
5110
5111<dt><pre>
5112DdNode * <i></i>
5113<a name="Cudd_addTimesPlus"><b>Cudd_addTimesPlus</b></a>(
5114  DdManager * <b>dd</b>, <i></i>
5115  DdNode * <b>A</b>, <i></i>
5116  DdNode * <b>B</b>, <i></i>
5117  DdNode ** <b>z</b>, <i></i>
5118  int  <b>nz</b> <i></i>
5119)
5120</pre>
5121<dd> Calculates the product of two matrices, A and B, represented as ADDs, using the CMU matrix by matrix multiplication procedure by Clarke et al.. Matrix A has x's as row variables and z's as column variables, while matrix B has z's as row variables and y's as column variables. Returns the pointer to the result if successful; NULL otherwise. The resulting matrix has x's as row variables and y's as column variables.
5122<p>
5123
5124<dd> <b>Side Effects</b> None
5125<p>
5126
5127<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_addMatrixMultiply">Cudd_addMatrixMultiply</a>
5128</code>
5129
5130<dt><pre>
5131DdNode * <i></i>
5132<a name="Cudd_addTimes"><b>Cudd_addTimes</b></a>(
5133  DdManager * <b>dd</b>, <i></i>
5134  DdNode ** <b>f</b>, <i></i>
5135  DdNode ** <b>g</b> <i></i>
5136)
5137</pre>
5138<dd> Integer and floating point multiplication. Returns NULL if not a terminal case; f * g otherwise. This function can be used also to take the AND of two 0-1 ADDs.
5139<p>
5140
5141<dd> <b>Side Effects</b> None
5142<p>
5143
5144<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_addApply">Cudd_addApply</a>
5145</code>
5146
5147<dt><pre>
5148DdNode * <i></i>
5149<a name="Cudd_addTriangle"><b>Cudd_addTriangle</b></a>(
5150  DdManager * <b>dd</b>, <i></i>
5151  DdNode * <b>f</b>, <i></i>
5152  DdNode * <b>g</b>, <i></i>
5153  DdNode ** <b>z</b>, <i></i>
5154  int  <b>nz</b> <i></i>
5155)
5156</pre>
5157<dd> Implements the semiring multiplication algorithm used in the triangulation step for the shortest path computation. f is assumed to depend on variables x (rows) and z (columns). g is assumed to depend on variables z (rows) and y (columns). The product of f and g then depends on x (rows) and y (columns). Only the z variables have to be explicitly identified; they are the "abstraction" variables. Returns a pointer to the result if successful; NULL otherwise.
5158<p>
5159
5160<dd> <b>Side Effects</b> None
5161<p>
5162
5163<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_addMatrixMultiply">Cudd_addMatrixMultiply</a>
5164<a href="cuddAllDet.html#Cudd_bddAndAbstract">Cudd_bddAndAbstract</a>
5165</code>
5166
5167<dt><pre>
5168DdNode * <i></i>
5169<a name="Cudd_addUnivAbstract"><b>Cudd_addUnivAbstract</b></a>(
5170  DdManager * <b>manager</b>, <i></i>
5171  DdNode * <b>f</b>, <i></i>
5172  DdNode * <b>cube</b> <i></i>
5173)
5174</pre>
5175<dd> Abstracts all the variables in cube from f by taking the product over all possible values taken by the variable. Returns the abstracted ADD if successful; NULL otherwise.
5176<p>
5177
5178<dd> <b>Side Effects</b> None
5179<p>
5180
5181<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_addExistAbstract">Cudd_addExistAbstract</a>
5182<a href="cuddAllDet.html#Cudd_bddUnivAbstract">Cudd_bddUnivAbstract</a>
5183<a href="cuddAllDet.html#Cudd_addOrAbstract">Cudd_addOrAbstract</a>
5184</code>
5185
5186<dt><pre>
5187DdNode * <i></i>
5188<a name="Cudd_addVectorCompose"><b>Cudd_addVectorCompose</b></a>(
5189  DdManager * <b>dd</b>, <i></i>
5190  DdNode * <b>f</b>, <i></i>
5191  DdNode ** <b>vector</b> <i></i>
5192)
5193</pre>
5194<dd> Given a vector of 0-1 ADDs, creates a new ADD by substituting the 0-1 ADDs for the variables of the ADD f. There should be an entry in vector for each variable in the manager. If no substitution is sought for a given variable, the corresponding projection function should be specified in the vector. This function implements simultaneous composition. Returns a pointer to the resulting ADD if successful; NULL otherwise.
5195<p>
5196
5197<dd> <b>Side Effects</b> None
5198<p>
5199
5200<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_addNonSimCompose">Cudd_addNonSimCompose</a>
5201<a href="cuddAllDet.html#Cudd_addPermute">Cudd_addPermute</a>
5202<a href="cuddAllDet.html#Cudd_addCompose">Cudd_addCompose</a>
5203<a href="cuddAllDet.html#Cudd_bddVectorCompose">Cudd_bddVectorCompose</a>
5204</code>
5205
5206<dt><pre>
5207DdNode * <i></i>
5208<a name="Cudd_addWalsh"><b>Cudd_addWalsh</b></a>(
5209  DdManager * <b>dd</b>, <i></i>
5210  DdNode ** <b>x</b>, <i></i>
5211  DdNode ** <b>y</b>, <i></i>
5212  int  <b>n</b> <i></i>
5213)
5214</pre>
5215<dd> Generates a Walsh matrix in ADD form. Returns a pointer to the matrixi if successful; NULL otherwise.
5216<p>
5217
5218<dd> <b>Side Effects</b> None
5219<p>
5220
5221<dt><pre>
5222DdNode * <i></i>
5223<a name="Cudd_addXeqy"><b>Cudd_addXeqy</b></a>(
5224  DdManager * <b>dd</b>, <i>DD manager</i>
5225  int  <b>N</b>, <i>number of x and y variables</i>
5226  DdNode ** <b>x</b>, <i>array of x variables</i>
5227  DdNode ** <b>y</b> <i>array of y variables</i>
5228)
5229</pre>
5230<dd> This function generates an ADD for the function x==y. Both x and y are N-bit numbers, x[0] x[1] ... x[N-1] and y[0] y[1] ... y[N-1], with 0 the most significant bit. The ADD is built bottom-up. It has 3*N-1 internal nodes, if the variables are ordered as follows: x[0] y[0] x[1] y[1] ... x[N-1] y[N-1].
5231<p>
5232
5233<dd> <b>Side Effects</b> None
5234<p>
5235
5236<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_Xeqy">Cudd_Xeqy</a>
5237</code>
5238
5239<dt><pre>
5240DdNode * <i></i>
5241<a name="Cudd_addXnor"><b>Cudd_addXnor</b></a>(
5242  DdManager * <b>dd</b>, <i></i>
5243  DdNode ** <b>f</b>, <i></i>
5244  DdNode ** <b>g</b> <i></i>
5245)
5246</pre>
5247<dd> XNOR of two 0-1 ADDs. Returns NULL if not a terminal case; f XNOR g otherwise.
5248<p>
5249
5250<dd> <b>Side Effects</b> None
5251<p>
5252
5253<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_addApply">Cudd_addApply</a>
5254</code>
5255
5256<dt><pre>
5257DdNode * <i></i>
5258<a name="Cudd_addXor"><b>Cudd_addXor</b></a>(
5259  DdManager * <b>dd</b>, <i></i>
5260  DdNode ** <b>f</b>, <i></i>
5261  DdNode ** <b>g</b> <i></i>
5262)
5263</pre>
5264<dd> XOR of two 0-1 ADDs. Returns NULL if not a terminal case; f XOR g otherwise.
5265<p>
5266
5267<dd> <b>Side Effects</b> None
5268<p>
5269
5270<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_addApply">Cudd_addApply</a>
5271</code>
5272
5273<dt><pre>
5274DdNode * <i></i>
5275<a name="Cudd_bddAdjPermuteX"><b>Cudd_bddAdjPermuteX</b></a>(
5276  DdManager * <b>dd</b>, <i></i>
5277  DdNode * <b>B</b>, <i></i>
5278  DdNode ** <b>x</b>, <i></i>
5279  int  <b>n</b> <i></i>
5280)
5281</pre>
5282<dd> Rearranges a set of variables in the BDD B. The size of the set is given by n. This procedure is intended for the `randomization' of the priority functions. Returns a pointer to the BDD if successful; NULL otherwise.
5283<p>
5284
5285<dd> <b>Side Effects</b> None
5286<p>
5287
5288<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_bddPermute">Cudd_bddPermute</a>
5289<a href="cuddAllDet.html#Cudd_bddSwapVariables">Cudd_bddSwapVariables</a>
5290<a href="cuddAllDet.html#Cudd_Dxygtdxz">Cudd_Dxygtdxz</a>
5291<a href="cuddAllDet.html#Cudd_Dxygtdyz">Cudd_Dxygtdyz</a>
5292<a href="cuddAllDet.html#Cudd_PrioritySelect">Cudd_PrioritySelect</a>
5293</code>
5294
5295<dt><pre>
5296DdNode * <i></i>
5297<a name="Cudd_bddAndAbstractLimit"><b>Cudd_bddAndAbstractLimit</b></a>(
5298  DdManager * <b>manager</b>, <i></i>
5299  DdNode * <b>f</b>, <i></i>
5300  DdNode * <b>g</b>, <i></i>
5301  DdNode * <b>cube</b>, <i></i>
5302  unsigned int  <b>limit</b> <i></i>
5303)
5304</pre>
5305<dd> Takes the AND of two BDDs and simultaneously abstracts the variables in cube. The variables are existentially abstracted. Returns a pointer to the result is successful; NULL otherwise. In particular, if the number of new nodes created exceeds <code>limit</code>, this function returns NULL.
5306<p>
5307
5308<dd> <b>Side Effects</b> None
5309<p>
5310
5311<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_bddAndAbstract">Cudd_bddAndAbstract</a>
5312</code>
5313
5314<dt><pre>
5315DdNode * <i></i>
5316<a name="Cudd_bddAndAbstract"><b>Cudd_bddAndAbstract</b></a>(
5317  DdManager * <b>manager</b>, <i></i>
5318  DdNode * <b>f</b>, <i></i>
5319  DdNode * <b>g</b>, <i></i>
5320  DdNode * <b>cube</b> <i></i>
5321)
5322</pre>
5323<dd> Takes the AND of two BDDs and simultaneously abstracts the variables in cube. The variables are existentially abstracted. Returns a pointer to the result is successful; NULL otherwise. Cudd_bddAndAbstract implements the semiring matrix multiplication algorithm for the boolean semiring.
5324<p>
5325
5326<dd> <b>Side Effects</b> None
5327<p>
5328
5329<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_addMatrixMultiply">Cudd_addMatrixMultiply</a>
5330<a href="cuddAllDet.html#Cudd_addTriangle">Cudd_addTriangle</a>
5331<a href="cuddAllDet.html#Cudd_bddAnd">Cudd_bddAnd</a>
5332</code>
5333
5334<dt><pre>
5335DdNode * <i></i>
5336<a name="Cudd_bddAndLimit"><b>Cudd_bddAndLimit</b></a>(
5337  DdManager * <b>dd</b>, <i></i>
5338  DdNode * <b>f</b>, <i></i>
5339  DdNode * <b>g</b>, <i></i>
5340  unsigned int  <b>limit</b> <i></i>
5341)
5342</pre>
5343<dd> Computes the conjunction of two BDDs f and g. Returns a pointer to the resulting BDD if successful; NULL if the intermediate result blows up or more new nodes than <code>limit</code> are required.
5344<p>
5345
5346<dd> <b>Side Effects</b> None
5347<p>
5348
5349<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_bddAnd">Cudd_bddAnd</a>
5350</code>
5351
5352<dt><pre>
5353DdNode * <i></i>
5354<a name="Cudd_bddAnd"><b>Cudd_bddAnd</b></a>(
5355  DdManager * <b>dd</b>, <i></i>
5356  DdNode * <b>f</b>, <i></i>
5357  DdNode * <b>g</b> <i></i>
5358)
5359</pre>
5360<dd> Computes the conjunction of two BDDs f and g. Returns a pointer to the resulting BDD if successful; NULL if the intermediate result blows up.
5361<p>
5362
5363<dd> <b>Side Effects</b> None
5364<p>
5365
5366<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_bddIte">Cudd_bddIte</a>
5367<a href="cuddAllDet.html#Cudd_addApply">Cudd_addApply</a>
5368<a href="cuddAllDet.html#Cudd_bddAndAbstract">Cudd_bddAndAbstract</a>
5369<a href="cuddAllDet.html#Cudd_bddIntersect">Cudd_bddIntersect</a>
5370<a href="cuddAllDet.html#Cudd_bddOr">Cudd_bddOr</a>
5371<a href="cuddAllDet.html#Cudd_bddNand">Cudd_bddNand</a>
5372<a href="cuddAllDet.html#Cudd_bddNor">Cudd_bddNor</a>
5373<a href="cuddAllDet.html#Cudd_bddXor">Cudd_bddXor</a>
5374<a href="cuddAllDet.html#Cudd_bddXnor">Cudd_bddXnor</a>
5375</code>
5376
5377<dt><pre>
5378int <i></i>
5379<a name="Cudd_bddApproxConjDecomp"><b>Cudd_bddApproxConjDecomp</b></a>(
5380  DdManager * <b>dd</b>, <i>manager</i>
5381  DdNode * <b>f</b>, <i>function to be decomposed</i>
5382  DdNode *** <b>conjuncts</b> <i>address of the first factor</i>
5383)
5384</pre>
5385<dd> Performs two-way conjunctive decomposition of a BDD. This procedure owes its name to the use of supersetting to obtain an initial factor of the given function. Returns the number of conjuncts produced, that is, 2 if successful; 1 if no meaningful decomposition was found; 0 otherwise. The conjuncts produced by this procedure tend to be imbalanced.
5386<p>
5387
5388<dd> <b>Side Effects</b> The factors are returned in an array as side effects. The array is allocated by this function. It is the caller's responsibility to free it. On successful completion, the conjuncts are already referenced. If the function returns 0, the array for the conjuncts is not allocated. If the function returns 1, the only factor equals the function to be decomposed.
5389<p>
5390
5391<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_bddApproxDisjDecomp">Cudd_bddApproxDisjDecomp</a>
5392<a href="cuddAllDet.html#Cudd_bddIterConjDecomp">Cudd_bddIterConjDecomp</a>
5393<a href="cuddAllDet.html#Cudd_bddGenConjDecomp">Cudd_bddGenConjDecomp</a>
5394<a href="cuddAllDet.html#Cudd_bddVarConjDecomp">Cudd_bddVarConjDecomp</a>
5395<a href="cuddAllDet.html#Cudd_RemapOverApprox">Cudd_RemapOverApprox</a>
5396<a href="cuddAllDet.html#Cudd_bddSqueeze">Cudd_bddSqueeze</a>
5397<a href="cuddAllDet.html#Cudd_bddLICompaction">Cudd_bddLICompaction</a>
5398</code>
5399
5400<dt><pre>
5401int <i></i>
5402<a name="Cudd_bddApproxDisjDecomp"><b>Cudd_bddApproxDisjDecomp</b></a>(
5403  DdManager * <b>dd</b>, <i>manager</i>
5404  DdNode * <b>f</b>, <i>function to be decomposed</i>
5405  DdNode *** <b>disjuncts</b> <i>address of the array of the disjuncts</i>
5406)
5407</pre>
5408<dd> Performs two-way disjunctive decomposition of a BDD. Returns the number of disjuncts produced, that is, 2 if successful; 1 if no meaningful decomposition was found; 0 otherwise. The disjuncts produced by this procedure tend to be imbalanced.
5409<p>
5410
5411<dd> <b>Side Effects</b> The two disjuncts are returned in an array as side effects. The array is allocated by this function. It is the caller's responsibility to free it. On successful completion, the disjuncts are already referenced. If the function returns 0, the array for the disjuncts is not allocated. If the function returns 1, the only factor equals the function to be decomposed.
5412<p>
5413
5414<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_bddApproxConjDecomp">Cudd_bddApproxConjDecomp</a>
5415<a href="cuddAllDet.html#Cudd_bddIterDisjDecomp">Cudd_bddIterDisjDecomp</a>
5416<a href="cuddAllDet.html#Cudd_bddGenDisjDecomp">Cudd_bddGenDisjDecomp</a>
5417<a href="cuddAllDet.html#Cudd_bddVarDisjDecomp">Cudd_bddVarDisjDecomp</a>
5418</code>
5419
5420<dt><pre>
5421int <i></i>
5422<a name="Cudd_bddBindVar"><b>Cudd_bddBindVar</b></a>(
5423  DdManager * <b>dd</b>, <i>manager</i>
5424  int  <b>index</b> <i>variable index</i>
5425)
5426</pre>
5427<dd> This function sets a flag to prevent sifting of a variable. Returns 1 if successful; 0 otherwise (i.e., invalid variable index).
5428<p>
5429
5430<dd> <b>Side Effects</b> Changes the "bindVar" flag in DdSubtable.
5431<p>
5432
5433<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_bddUnbindVar">Cudd_bddUnbindVar</a>
5434</code>
5435
5436<dt><pre>
5437DdNode * <i></i>
5438<a name="Cudd_bddBooleanDiff"><b>Cudd_bddBooleanDiff</b></a>(
5439  DdManager * <b>manager</b>, <i></i>
5440  DdNode * <b>f</b>, <i></i>
5441  int  <b>x</b> <i></i>
5442)
5443</pre>
5444<dd> Computes the boolean difference of f with respect to the variable with index x. Returns the BDD of the boolean difference if successful; NULL otherwise.
5445<p>
5446
5447<dd> <b>Side Effects</b> None
5448<p>
5449
5450<dt><pre>
5451DdNode ** <i></i>
5452<a name="Cudd_bddCharToVect"><b>Cudd_bddCharToVect</b></a>(
5453  DdManager * <b>dd</b>, <i></i>
5454  DdNode * <b>f</b> <i></i>
5455)
5456</pre>
5457<dd> Computes a vector of BDDs whose image equals a non-zero function. The result depends on the variable order. The i-th component of the vector depends only on the first i variables in the order. Each BDD in the vector is not larger than the BDD of the given characteristic function. This function is based on the description of char-to-vect in "Verification of Sequential Machines Using Boolean Functional Vectors" by O. Coudert, C. Berthet and J. C. Madre. Returns a pointer to an array containing the result if successful; NULL otherwise. The size of the array equals the number of variables in the manager. The components of the solution have their reference counts already incremented (unlike the results of most other functions in the package).
5458<p>
5459
5460<dd> <b>Side Effects</b> None
5461<p>
5462
5463<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_bddConstrain">Cudd_bddConstrain</a>
5464</code>
5465
5466<dt><pre>
5467DdNode * <i></i>
5468<a name="Cudd_bddClippingAndAbstract"><b>Cudd_bddClippingAndAbstract</b></a>(
5469  DdManager * <b>dd</b>, <i>manager</i>
5470  DdNode * <b>f</b>, <i>first conjunct</i>
5471  DdNode * <b>g</b>, <i>second conjunct</i>
5472  DdNode * <b>cube</b>, <i>cube of variables to be abstracted</i>
5473  int  <b>maxDepth</b>, <i>maximum recursion depth</i>
5474  int  <b>direction</b> <i>under (0) or over (1) approximation</i>
5475)
5476</pre>
5477<dd> Approximates the conjunction of two BDDs f and g and simultaneously abstracts the variables in cube. The variables are existentially abstracted. Returns a pointer to the resulting BDD if successful; NULL if the intermediate result blows up.
5478<p>
5479
5480<dd> <b>Side Effects</b> None
5481<p>
5482
5483<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_bddAndAbstract">Cudd_bddAndAbstract</a>
5484<a href="cuddAllDet.html#Cudd_bddClippingAnd">Cudd_bddClippingAnd</a>
5485</code>
5486
5487<dt><pre>
5488DdNode * <i></i>
5489<a name="Cudd_bddClippingAnd"><b>Cudd_bddClippingAnd</b></a>(
5490  DdManager * <b>dd</b>, <i>manager</i>
5491  DdNode * <b>f</b>, <i>first conjunct</i>
5492  DdNode * <b>g</b>, <i>second conjunct</i>
5493  int  <b>maxDepth</b>, <i>maximum recursion depth</i>
5494  int  <b>direction</b> <i>under (0) or over (1) approximation</i>
5495)
5496</pre>
5497<dd> Approximates the conjunction of two BDDs f and g. Returns a pointer to the resulting BDD if successful; NULL if the intermediate result blows up.
5498<p>
5499
5500<dd> <b>Side Effects</b> None
5501<p>
5502
5503<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_bddAnd">Cudd_bddAnd</a>
5504</code>
5505
5506<dt><pre>
5507DdNode * <i></i>
5508<a name="Cudd_bddClosestCube"><b>Cudd_bddClosestCube</b></a>(
5509  DdManager * <b>dd</b>, <i></i>
5510  DdNode * <b>f</b>, <i></i>
5511  DdNode * <b>g</b>, <i></i>
5512  int * <b>distance</b> <i></i>
5513)
5514</pre>
5515<dd> Finds a cube of f at minimum Hamming distance from the minterms of g. All the minterms of the cube are at the minimum distance. If the distance is 0, the cube belongs to the intersection of f and g. Returns the cube if successful; NULL otherwise.
5516<p>
5517
5518<dd> <b>Side Effects</b> The distance is returned as a side effect.
5519<p>
5520
5521<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_MinHammingDist">Cudd_MinHammingDist</a>
5522</code>
5523
5524<dt><pre>
5525DdNode * <i></i>
5526<a name="Cudd_bddCompose"><b>Cudd_bddCompose</b></a>(
5527  DdManager * <b>dd</b>, <i></i>
5528  DdNode * <b>f</b>, <i></i>
5529  DdNode * <b>g</b>, <i></i>
5530  int  <b>v</b> <i></i>
5531)
5532</pre>
5533<dd> Substitutes g for x_v in the BDD for f. v is the index of the variable to be substituted. Cudd_bddCompose passes the corresponding projection function to the recursive procedure, so that the cache may be used. Returns the composed BDD if successful; NULL otherwise.
5534<p>
5535
5536<dd> <b>Side Effects</b> None
5537<p>
5538
5539<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_addCompose">Cudd_addCompose</a>
5540</code>
5541
5542<dt><pre>
5543DdNode * <i></i>
5544<a name="Cudd_bddComputeCube"><b>Cudd_bddComputeCube</b></a>(
5545  DdManager * <b>dd</b>, <i></i>
5546  DdNode ** <b>vars</b>, <i></i>
5547  int * <b>phase</b>, <i></i>
5548  int  <b>n</b> <i></i>
5549)
5550</pre>
5551<dd> Computes the cube of an array of BDD variables. If non-null, the phase argument indicates which literal of each variable should appear in the cube. If phase[i] is nonzero, then the positive literal is used. If phase is NULL, the cube is positive unate. Returns a pointer to the result if successful; NULL otherwise.
5552<p>
5553
5554<dd> <b>Side Effects</b> None
5555<p>
5556
5557<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_addComputeCube">Cudd_addComputeCube</a>
5558<a href="cuddAllDet.html#Cudd_IndicesToCube">Cudd_IndicesToCube</a>
5559<a href="cuddAllDet.html#Cudd_CubeArrayToBdd">Cudd_CubeArrayToBdd</a>
5560</code>
5561
5562<dt><pre>
5563DdNode ** <i></i>
5564<a name="Cudd_bddConstrainDecomp"><b>Cudd_bddConstrainDecomp</b></a>(
5565  DdManager * <b>dd</b>, <i></i>
5566  DdNode * <b>f</b> <i></i>
5567)
5568</pre>
5569<dd> BDD conjunctive decomposition as in McMillan's CAV96 paper. The decomposition is canonical only for a given variable order. If canonicity is required, variable ordering must be disabled after the decomposition has been computed. Returns an array with one entry for each BDD variable in the manager if successful; otherwise NULL. The components of the solution have their reference counts already incremented (unlike the results of most other functions in the package.
5570<p>
5571
5572<dd> <b>Side Effects</b> None
5573<p>
5574
5575<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_bddConstrain">Cudd_bddConstrain</a>
5576<a href="cuddAllDet.html#Cudd_bddExistAbstract">Cudd_bddExistAbstract</a>
5577</code>
5578
5579<dt><pre>
5580DdNode * <i></i>
5581<a name="Cudd_bddConstrain"><b>Cudd_bddConstrain</b></a>(
5582  DdManager * <b>dd</b>, <i></i>
5583  DdNode * <b>f</b>, <i></i>
5584  DdNode * <b>c</b> <i></i>
5585)
5586</pre>
5587<dd> Computes f constrain c (f @ c). Uses a canonical form: (f' @ c) = ( f @ c)'. (Note: this is not true for c.) List of special cases: <ul> <li> f @ 0 = 0 <li> f @ 1 = f <li> 0 @ c = 0 <li> 1 @ c = 1 <li> f @ f = 1 <li> f @ f'= 0 </ul> Returns a pointer to the result if successful; NULL otherwise. Note that if F=(f1,...,fn) and reordering takes place while computing F @ c, then the image restriction property (Img(F,c) = Img(F @ c)) is lost.
5588<p>
5589
5590<dd> <b>Side Effects</b> None
5591<p>
5592
5593<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_bddRestrict">Cudd_bddRestrict</a>
5594<a href="cuddAllDet.html#Cudd_addConstrain">Cudd_addConstrain</a>
5595</code>
5596
5597<dt><pre>
5598double <i></i>
5599<a name="Cudd_bddCorrelationWeights"><b>Cudd_bddCorrelationWeights</b></a>(
5600  DdManager * <b>manager</b>, <i></i>
5601  DdNode * <b>f</b>, <i></i>
5602  DdNode * <b>g</b>, <i></i>
5603  double * <b>prob</b> <i></i>
5604)
5605</pre>
5606<dd> Computes the correlation of f and g for given input probabilities. On input, prob[i] is supposed to contain the probability of the i-th input variable to be 1. If f == g, their correlation is 1. If f == g', their correlation is 0. Returns the probability that f and g have the same value. If it runs out of memory, returns (double)CUDD_OUT_OF_MEM. The correlation of f and the constant one gives the probability of f.
5607<p>
5608
5609<dd> <b>Side Effects</b> None
5610<p>
5611
5612<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_bddCorrelation">Cudd_bddCorrelation</a>
5613</code>
5614
5615<dt><pre>
5616double <i></i>
5617<a name="Cudd_bddCorrelation"><b>Cudd_bddCorrelation</b></a>(
5618  DdManager * <b>manager</b>, <i></i>
5619  DdNode * <b>f</b>, <i></i>
5620  DdNode * <b>g</b> <i></i>
5621)
5622</pre>
5623<dd> Computes the correlation of f and g. If f == g, their correlation is 1. If f == g', their correlation is 0. Returns the fraction of minterms in the ON-set of the EXNOR of f and g. If it runs out of memory, returns (double)CUDD_OUT_OF_MEM.
5624<p>
5625
5626<dd> <b>Side Effects</b> None
5627<p>
5628
5629<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_bddCorrelationWeights">Cudd_bddCorrelationWeights</a>
5630</code>
5631
5632<dt><pre>
5633DdNode * <i></i>
5634<a name="Cudd_bddExistAbstract"><b>Cudd_bddExistAbstract</b></a>(
5635  DdManager * <b>manager</b>, <i></i>
5636  DdNode * <b>f</b>, <i></i>
5637  DdNode * <b>cube</b> <i></i>
5638)
5639</pre>
5640<dd> Existentially abstracts all the variables in cube from f. Returns the abstracted BDD if successful; NULL otherwise.
5641<p>
5642
5643<dd> <b>Side Effects</b> None
5644<p>
5645
5646<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_bddUnivAbstract">Cudd_bddUnivAbstract</a>
5647<a href="cuddAllDet.html#Cudd_addExistAbstract">Cudd_addExistAbstract</a>
5648</code>
5649
5650<dt><pre>
5651int <i></i>
5652<a name="Cudd_bddGenConjDecomp"><b>Cudd_bddGenConjDecomp</b></a>(
5653  DdManager * <b>dd</b>, <i>manager</i>
5654  DdNode * <b>f</b>, <i>function to be decomposed</i>
5655  DdNode *** <b>conjuncts</b> <i>address of the array of conjuncts</i>
5656)
5657</pre>
5658<dd> Performs two-way conjunctive decomposition of a BDD. This procedure owes its name to the fact tht it generalizes the decomposition based on the cofactors with respect to one variable. Returns the number of conjuncts produced, that is, 2 if successful; 1 if no meaningful decomposition was found; 0 otherwise. The conjuncts produced by this procedure tend to be balanced.
5659<p>
5660
5661<dd> <b>Side Effects</b> The two factors are returned in an array as side effects. The array is allocated by this function. It is the caller's responsibility to free it. On successful completion, the conjuncts are already referenced. If the function returns 0, the array for the conjuncts is not allocated. If the function returns 1, the only factor equals the function to be decomposed.
5662<p>
5663
5664<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_bddGenDisjDecomp">Cudd_bddGenDisjDecomp</a>
5665<a href="cuddAllDet.html#Cudd_bddApproxConjDecomp">Cudd_bddApproxConjDecomp</a>
5666<a href="cuddAllDet.html#Cudd_bddIterConjDecomp">Cudd_bddIterConjDecomp</a>
5667<a href="cuddAllDet.html#Cudd_bddVarConjDecomp">Cudd_bddVarConjDecomp</a>
5668</code>
5669
5670<dt><pre>
5671int <i></i>
5672<a name="Cudd_bddGenDisjDecomp"><b>Cudd_bddGenDisjDecomp</b></a>(
5673  DdManager * <b>dd</b>, <i>manager</i>
5674  DdNode * <b>f</b>, <i>function to be decomposed</i>
5675  DdNode *** <b>disjuncts</b> <i>address of the array of the disjuncts</i>
5676)
5677</pre>
5678<dd> Performs two-way disjunctive decomposition of a BDD. Returns the number of disjuncts produced, that is, 2 if successful; 1 if no meaningful decomposition was found; 0 otherwise. The disjuncts produced by this procedure tend to be balanced.
5679<p>
5680
5681<dd> <b>Side Effects</b> The two disjuncts are returned in an array as side effects. The array is allocated by this function. It is the caller's responsibility to free it. On successful completion, the disjuncts are already referenced. If the function returns 0, the array for the disjuncts is not allocated. If the function returns 1, the only factor equals the function to be decomposed.
5682<p>
5683
5684<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_bddGenConjDecomp">Cudd_bddGenConjDecomp</a>
5685<a href="cuddAllDet.html#Cudd_bddApproxDisjDecomp">Cudd_bddApproxDisjDecomp</a>
5686<a href="cuddAllDet.html#Cudd_bddIterDisjDecomp">Cudd_bddIterDisjDecomp</a>
5687<a href="cuddAllDet.html#Cudd_bddVarDisjDecomp">Cudd_bddVarDisjDecomp</a>
5688</code>
5689
5690<dt><pre>
5691DdNode * <i></i>
5692<a name="Cudd_bddIntersect"><b>Cudd_bddIntersect</b></a>(
5693  DdManager * <b>dd</b>, <i>manager</i>
5694  DdNode * <b>f</b>, <i>first operand</i>
5695  DdNode * <b>g</b> <i>second operand</i>
5696)
5697</pre>
5698<dd> Computes a function included in the intersection of f and g. (That is, a witness that the intersection is not empty.) Cudd_bddIntersect tries to build as few new nodes as possible. If the only result of interest is whether f and g intersect, Cudd_bddLeq should be used instead.
5699<p>
5700
5701<dd> <b>Side Effects</b> None
5702<p>
5703
5704<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_bddLeq">Cudd_bddLeq</a>
5705<a href="cuddAllDet.html#Cudd_bddIteConstant">Cudd_bddIteConstant</a>
5706</code>
5707
5708<dt><pre>
5709int <i></i>
5710<a name="Cudd_bddIsNsVar"><b>Cudd_bddIsNsVar</b></a>(
5711  DdManager * <b>dd</b>, <i></i>
5712  int  <b>index</b> <i></i>
5713)
5714</pre>
5715<dd> Checks whether a variable is next state. Returns 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.
5716<p>
5717
5718<dd> <b>Side Effects</b> none
5719<p>
5720
5721<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_bddSetNsVar">Cudd_bddSetNsVar</a>
5722<a href="cuddAllDet.html#Cudd_bddIsPiVar">Cudd_bddIsPiVar</a>
5723<a href="cuddAllDet.html#Cudd_bddIsPsVar">Cudd_bddIsPsVar</a>
5724</code>
5725
5726<dt><pre>
5727int <i></i>
5728<a name="Cudd_bddIsPiVar"><b>Cudd_bddIsPiVar</b></a>(
5729  DdManager * <b>dd</b>, <i>manager</i>
5730  int  <b>index</b> <i>variable index</i>
5731)
5732</pre>
5733<dd> Checks whether a variable is primary input. Returns 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.
5734<p>
5735
5736<dd> <b>Side Effects</b> none
5737<p>
5738
5739<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_bddSetPiVar">Cudd_bddSetPiVar</a>
5740<a href="cuddAllDet.html#Cudd_bddIsPsVar">Cudd_bddIsPsVar</a>
5741<a href="cuddAllDet.html#Cudd_bddIsNsVar">Cudd_bddIsNsVar</a>
5742</code>
5743
5744<dt><pre>
5745int <i></i>
5746<a name="Cudd_bddIsPsVar"><b>Cudd_bddIsPsVar</b></a>(
5747  DdManager * <b>dd</b>, <i></i>
5748  int  <b>index</b> <i></i>
5749)
5750</pre>
5751<dd> Checks whether a variable is present state. Returns 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.
5752<p>
5753
5754<dd> <b>Side Effects</b> none
5755<p>
5756
5757<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_bddSetPsVar">Cudd_bddSetPsVar</a>
5758<a href="cuddAllDet.html#Cudd_bddIsPiVar">Cudd_bddIsPiVar</a>
5759<a href="cuddAllDet.html#Cudd_bddIsNsVar">Cudd_bddIsNsVar</a>
5760</code>
5761
5762<dt><pre>
5763int <i></i>
5764<a name="Cudd_bddIsVarEssential"><b>Cudd_bddIsVarEssential</b></a>(
5765  DdManager * <b>manager</b>, <i></i>
5766  DdNode * <b>f</b>, <i></i>
5767  int  <b>id</b>, <i></i>
5768  int  <b>phase</b> <i></i>
5769)
5770</pre>
5771<dd> Determines whether a given variable is essential with a given phase in a BDD. Uses Cudd_bddIteConstant. Returns 1 if phase == 1 and f-->x_id, or if phase == 0 and f-->x_id'.
5772<p>
5773
5774<dd> <b>Side Effects</b> None
5775<p>
5776
5777<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_FindEssential">Cudd_FindEssential</a>
5778</code>
5779
5780<dt><pre>
5781int <i></i>
5782<a name="Cudd_bddIsVarHardGroup"><b>Cudd_bddIsVarHardGroup</b></a>(
5783  DdManager * <b>dd</b>, <i></i>
5784  int  <b>index</b> <i></i>
5785)
5786</pre>
5787<dd> Checks whether a variable is set to be in a hard group. This function is used for lazy sifting. Returns 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.
5788<p>
5789
5790<dd> <b>Side Effects</b> none
5791<p>
5792
5793<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_bddSetVarHardGroup">Cudd_bddSetVarHardGroup</a>
5794</code>
5795
5796<dt><pre>
5797int <i></i>
5798<a name="Cudd_bddIsVarToBeGrouped"><b>Cudd_bddIsVarToBeGrouped</b></a>(
5799  DdManager * <b>dd</b>, <i></i>
5800  int  <b>index</b> <i></i>
5801)
5802</pre>
5803<dd> Checks whether a variable is set to be grouped. This function is used for lazy sifting.
5804<p>
5805
5806<dd> <b>Side Effects</b> none
5807<p>
5808
5809<dt><pre>
5810int <i></i>
5811<a name="Cudd_bddIsVarToBeUngrouped"><b>Cudd_bddIsVarToBeUngrouped</b></a>(
5812  DdManager * <b>dd</b>, <i></i>
5813  int  <b>index</b> <i></i>
5814)
5815</pre>
5816<dd> Checks whether a variable is set to be ungrouped. This function is used for lazy sifting. Returns 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.
5817<p>
5818
5819<dd> <b>Side Effects</b> none
5820<p>
5821
5822<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_bddSetVarToBeUngrouped">Cudd_bddSetVarToBeUngrouped</a>
5823</code>
5824
5825<dt><pre>
5826DdNode  * <i></i>
5827<a name="Cudd_bddIsop"><b>Cudd_bddIsop</b></a>(
5828  DdManager * <b>dd</b>, <i></i>
5829  DdNode * <b>L</b>, <i></i>
5830  DdNode * <b>U</b> <i></i>
5831)
5832</pre>
5833<dd> Computes a BDD in the interval between L and U with a simple sum-of-produuct cover. This procedure is similar to Cudd_zddIsop, but it does not return the ZDD for the cover. Returns a pointer to the BDD if successful; NULL otherwise.
5834<p>
5835
5836<dd> <b>Side Effects</b> None
5837<p>
5838
5839<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_zddIsop">Cudd_zddIsop</a>
5840</code>
5841
5842<dt><pre>
5843DdNode * <i></i>
5844<a name="Cudd_bddIteConstant"><b>Cudd_bddIteConstant</b></a>(
5845  DdManager * <b>dd</b>, <i></i>
5846  DdNode * <b>f</b>, <i></i>
5847  DdNode * <b>g</b>, <i></i>
5848  DdNode * <b>h</b> <i></i>
5849)
5850</pre>
5851<dd> Implements ITEconstant(f,g,h). Returns a pointer to the resulting BDD (which may or may not be constant) or DD_NON_CONSTANT. No new nodes are created.
5852<p>
5853
5854<dd> <b>Side Effects</b> None
5855<p>
5856
5857<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_bddIte">Cudd_bddIte</a>
5858<a href="cuddAllDet.html#Cudd_bddIntersect">Cudd_bddIntersect</a>
5859<a href="cuddAllDet.html#Cudd_bddLeq">Cudd_bddLeq</a>
5860<a href="cuddAllDet.html#Cudd_addIteConstant">Cudd_addIteConstant</a>
5861</code>
5862
5863<dt><pre>
5864int <i></i>
5865<a name="Cudd_bddIterConjDecomp"><b>Cudd_bddIterConjDecomp</b></a>(
5866  DdManager * <b>dd</b>, <i>manager</i>
5867  DdNode * <b>f</b>, <i>function to be decomposed</i>
5868  DdNode *** <b>conjuncts</b> <i>address of the array of conjuncts</i>
5869)
5870</pre>
5871<dd> Performs two-way conjunctive decomposition of a BDD. This procedure owes its name to the iterated use of supersetting to obtain a factor of the given function. Returns the number of conjuncts produced, that is, 2 if successful; 1 if no meaningful decomposition was found; 0 otherwise. The conjuncts produced by this procedure tend to be imbalanced.
5872<p>
5873
5874<dd> <b>Side Effects</b> The factors are returned in an array as side effects. The array is allocated by this function. It is the caller's responsibility to free it. On successful completion, the conjuncts are already referenced. If the function returns 0, the array for the conjuncts is not allocated. If the function returns 1, the only factor equals the function to be decomposed.
5875<p>
5876
5877<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_bddIterDisjDecomp">Cudd_bddIterDisjDecomp</a>
5878<a href="cuddAllDet.html#Cudd_bddApproxConjDecomp">Cudd_bddApproxConjDecomp</a>
5879<a href="cuddAllDet.html#Cudd_bddGenConjDecomp">Cudd_bddGenConjDecomp</a>
5880<a href="cuddAllDet.html#Cudd_bddVarConjDecomp">Cudd_bddVarConjDecomp</a>
5881<a href="cuddAllDet.html#Cudd_RemapOverApprox">Cudd_RemapOverApprox</a>
5882<a href="cuddAllDet.html#Cudd_bddSqueeze">Cudd_bddSqueeze</a>
5883<a href="cuddAllDet.html#Cudd_bddLICompaction">Cudd_bddLICompaction</a>
5884</code>
5885
5886<dt><pre>
5887int <i></i>
5888<a name="Cudd_bddIterDisjDecomp"><b>Cudd_bddIterDisjDecomp</b></a>(
5889  DdManager * <b>dd</b>, <i>manager</i>
5890  DdNode * <b>f</b>, <i>function to be decomposed</i>
5891  DdNode *** <b>disjuncts</b> <i>address of the array of the disjuncts</i>
5892)
5893</pre>
5894<dd> Performs two-way disjunctive decomposition of a BDD. Returns the number of disjuncts produced, that is, 2 if successful; 1 if no meaningful decomposition was found; 0 otherwise. The disjuncts produced by this procedure tend to be imbalanced.
5895<p>
5896
5897<dd> <b>Side Effects</b> The two disjuncts are returned in an array as side effects. The array is allocated by this function. It is the caller's responsibility to free it. On successful completion, the disjuncts are already referenced. If the function returns 0, the array for the disjuncts is not allocated. If the function returns 1, the only factor equals the function to be decomposed.
5898<p>
5899
5900<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_bddIterConjDecomp">Cudd_bddIterConjDecomp</a>
5901<a href="cuddAllDet.html#Cudd_bddApproxDisjDecomp">Cudd_bddApproxDisjDecomp</a>
5902<a href="cuddAllDet.html#Cudd_bddGenDisjDecomp">Cudd_bddGenDisjDecomp</a>
5903<a href="cuddAllDet.html#Cudd_bddVarDisjDecomp">Cudd_bddVarDisjDecomp</a>
5904</code>
5905
5906<dt><pre>
5907DdNode * <i></i>
5908<a name="Cudd_bddIte"><b>Cudd_bddIte</b></a>(
5909  DdManager * <b>dd</b>, <i></i>
5910  DdNode * <b>f</b>, <i></i>
5911  DdNode * <b>g</b>, <i></i>
5912  DdNode * <b>h</b> <i></i>
5913)
5914</pre>
5915<dd> Implements ITE(f,g,h). Returns a pointer to the resulting BDD if successful; NULL if the intermediate result blows up.
5916<p>
5917
5918<dd> <b>Side Effects</b> None
5919<p>
5920
5921<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_addIte">Cudd_addIte</a>
5922<a href="cuddAllDet.html#Cudd_bddIteConstant">Cudd_bddIteConstant</a>
5923<a href="cuddAllDet.html#Cudd_bddIntersect">Cudd_bddIntersect</a>
5924</code>
5925
5926<dt><pre>
5927DdNode * <i></i>
5928<a name="Cudd_bddIthVar"><b>Cudd_bddIthVar</b></a>(
5929  DdManager * <b>dd</b>, <i></i>
5930  int  <b>i</b> <i></i>
5931)
5932</pre>
5933<dd> Retrieves the BDD variable with index i if it already exists, or creates a new BDD variable. Returns a pointer to the variable if successful; NULL otherwise.
5934<p>
5935
5936<dd> <b>Side Effects</b> None
5937<p>
5938
5939<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_bddNewVar">Cudd_bddNewVar</a>
5940<a href="cuddAllDet.html#Cudd_addIthVar">Cudd_addIthVar</a>
5941<a href="cuddAllDet.html#Cudd_bddNewVarAtLevel">Cudd_bddNewVarAtLevel</a>
5942<a href="cuddAllDet.html#Cudd_ReadVars">Cudd_ReadVars</a>
5943</code>
5944
5945<dt><pre>
5946DdNode * <i></i>
5947<a name="Cudd_bddLICompaction"><b>Cudd_bddLICompaction</b></a>(
5948  DdManager * <b>dd</b>, <i>manager</i>
5949  DdNode * <b>f</b>, <i>function to be minimized</i>
5950  DdNode * <b>c</b> <i>constraint (care set)</i>
5951)
5952</pre>
5953<dd> Performs safe minimization of a BDD. Given the BDD <code>f</code> of a function to be minimized and a BDD <code>c</code> representing the care set, Cudd_bddLICompaction produces the BDD of a function that agrees with <code>f</code> wherever <code>c</code> is 1. Safe minimization means that the size of the result is guaranteed not to exceed the size of <code>f</code>. This function is based on the DAC97 paper by Hong et al.. Returns a pointer to the result if successful; NULL otherwise.
5954<p>
5955
5956<dd> <b>Side Effects</b> None
5957<p>
5958
5959<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_bddRestrict">Cudd_bddRestrict</a>
5960</code>
5961
5962<dt><pre>
5963int <i></i>
5964<a name="Cudd_bddLeqUnless"><b>Cudd_bddLeqUnless</b></a>(
5965  DdManager * <b>dd</b>, <i></i>
5966  DdNode * <b>f</b>, <i></i>
5967  DdNode * <b>g</b>, <i></i>
5968  DdNode * <b>D</b> <i></i>
5969)
5970</pre>
5971<dd> Tells whether f is less than of equal to G unless D is 1. f, g, and D are BDDs. The function returns 1 if f is less than of equal to G, and 0 otherwise. No new nodes are created.
5972<p>
5973
5974<dd> <b>Side Effects</b> None
5975<p>
5976
5977<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_EquivDC">Cudd_EquivDC</a>
5978<a href="cuddAllDet.html#Cudd_bddLeq">Cudd_bddLeq</a>
5979<a href="cuddAllDet.html#Cudd_bddIteConstant">Cudd_bddIteConstant</a>
5980</code>
5981
5982<dt><pre>
5983int <i></i>
5984<a name="Cudd_bddLeq"><b>Cudd_bddLeq</b></a>(
5985  DdManager * <b>dd</b>, <i></i>
5986  DdNode * <b>f</b>, <i></i>
5987  DdNode * <b>g</b> <i></i>
5988)
5989</pre>
5990<dd> Returns 1 if f is less than or equal to g; 0 otherwise. No new nodes are created.
5991<p>
5992
5993<dd> <b>Side Effects</b> None
5994<p>
5995
5996<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_bddIteConstant">Cudd_bddIteConstant</a>
5997<a href="cuddAllDet.html#Cudd_addEvalConst">Cudd_addEvalConst</a>
5998</code>
5999
6000<dt><pre>
6001DdNode * <i></i>
6002<a name="Cudd_bddLiteralSetIntersection"><b>Cudd_bddLiteralSetIntersection</b></a>(
6003  DdManager * <b>dd</b>, <i></i>
6004  DdNode * <b>f</b>, <i></i>
6005  DdNode * <b>g</b> <i></i>
6006)
6007</pre>
6008<dd> Computes the intesection of two sets of literals represented as BDDs. Each set is represented as a cube of the literals in the set. The empty set is represented by the constant 1. No variable can be simultaneously present in both phases in a set. Returns a pointer to the BDD representing the intersected sets, if successful; NULL otherwise.
6009<p>
6010
6011<dd> <b>Side Effects</b> None
6012<p>
6013
6014<dt><pre>
6015DdNode * <i></i>
6016<a name="Cudd_bddMakePrime"><b>Cudd_bddMakePrime</b></a>(
6017  DdManager * <b>dd</b>, <i>manager</i>
6018  DdNode * <b>cube</b>, <i>cube to be expanded</i>
6019  DdNode * <b>f</b> <i>function of which the cube is to be made a prime</i>
6020)
6021</pre>
6022<dd> Expands cube to a prime implicant of f. Returns the prime if successful; NULL otherwise. In particular, NULL is returned if cube is not a real cube or is not an implicant of f.
6023<p>
6024
6025<dd> <b>Side Effects</b> None
6026<p>
6027
6028<dt><pre>
6029DdNode * <i></i>
6030<a name="Cudd_bddMinimize"><b>Cudd_bddMinimize</b></a>(
6031  DdManager * <b>dd</b>, <i></i>
6032  DdNode * <b>f</b>, <i></i>
6033  DdNode * <b>c</b> <i></i>
6034)
6035</pre>
6036<dd> Finds a small BDD that agrees with <code>f</code> over <code>c</code>. Returns a pointer to the result if successful; NULL otherwise.
6037<p>
6038
6039<dd> <b>Side Effects</b> None
6040<p>
6041
6042<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_bddRestrict">Cudd_bddRestrict</a>
6043<a href="cuddAllDet.html#Cudd_bddLICompaction">Cudd_bddLICompaction</a>
6044<a href="cuddAllDet.html#Cudd_bddSqueeze">Cudd_bddSqueeze</a>
6045</code>
6046
6047<dt><pre>
6048DdNode * <i></i>
6049<a name="Cudd_bddNPAnd"><b>Cudd_bddNPAnd</b></a>(
6050  DdManager * <b>dd</b>, <i></i>
6051  DdNode * <b>f</b>, <i></i>
6052  DdNode * <b>g</b> <i></i>
6053)
6054</pre>
6055<dd> Computes f non-polluting-and g. The non-polluting AND of f and g is a hybrid of AND and Restrict. From Restrict, this operation takes the idea of existentially quantifying the top variable of the second operand if it does not appear in the first. Therefore, the variables that appear in the result also appear in f. For the rest, the function behaves like AND. Since the two operands play different roles, non-polluting AND is not commutative. Returns a pointer to the result if successful; NULL otherwise.
6056<p>
6057
6058<dd> <b>Side Effects</b> None
6059<p>
6060
6061<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_bddConstrain">Cudd_bddConstrain</a>
6062<a href="cuddAllDet.html#Cudd_bddRestrict">Cudd_bddRestrict</a>
6063</code>
6064
6065<dt><pre>
6066DdNode * <i></i>
6067<a name="Cudd_bddNand"><b>Cudd_bddNand</b></a>(
6068  DdManager * <b>dd</b>, <i></i>
6069  DdNode * <b>f</b>, <i></i>
6070  DdNode * <b>g</b> <i></i>
6071)
6072</pre>
6073<dd> Computes the NAND of two BDDs f and g. Returns a pointer to the resulting BDD if successful; NULL if the intermediate result blows up.
6074<p>
6075
6076<dd> <b>Side Effects</b> None
6077<p>
6078
6079<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_bddIte">Cudd_bddIte</a>
6080<a href="cuddAllDet.html#Cudd_addApply">Cudd_addApply</a>
6081<a href="cuddAllDet.html#Cudd_bddAnd">Cudd_bddAnd</a>
6082<a href="cuddAllDet.html#Cudd_bddOr">Cudd_bddOr</a>
6083<a href="cuddAllDet.html#Cudd_bddNor">Cudd_bddNor</a>
6084<a href="cuddAllDet.html#Cudd_bddXor">Cudd_bddXor</a>
6085<a href="cuddAllDet.html#Cudd_bddXnor">Cudd_bddXnor</a>
6086</code>
6087
6088<dt><pre>
6089DdNode * <i></i>
6090<a name="Cudd_bddNewVarAtLevel"><b>Cudd_bddNewVarAtLevel</b></a>(
6091  DdManager * <b>dd</b>, <i></i>
6092  int  <b>level</b> <i></i>
6093)
6094</pre>
6095<dd> Creates a new BDD variable. The new variable has an index equal to the largest previous index plus 1 and is positioned at the specified level in the order. Returns a pointer to the new variable if successful; NULL otherwise.
6096<p>
6097
6098<dd> <b>Side Effects</b> None
6099<p>
6100
6101<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_bddNewVar">Cudd_bddNewVar</a>
6102<a href="cuddAllDet.html#Cudd_bddIthVar">Cudd_bddIthVar</a>
6103<a href="cuddAllDet.html#Cudd_addNewVarAtLevel">Cudd_addNewVarAtLevel</a>
6104</code>
6105
6106<dt><pre>
6107DdNode * <i></i>
6108<a name="Cudd_bddNewVar"><b>Cudd_bddNewVar</b></a>(
6109  DdManager * <b>dd</b> <i></i>
6110)
6111</pre>
6112<dd> Creates a new BDD variable. The new variable has an index equal to the largest previous index plus 1. Returns a pointer to the new variable if successful; NULL otherwise.
6113<p>
6114
6115<dd> <b>Side Effects</b> None
6116<p>
6117
6118<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_addNewVar">Cudd_addNewVar</a>
6119<a href="cuddAllDet.html#Cudd_bddIthVar">Cudd_bddIthVar</a>
6120<a href="cuddAllDet.html#Cudd_bddNewVarAtLevel">Cudd_bddNewVarAtLevel</a>
6121</code>
6122
6123<dt><pre>
6124DdNode * <i></i>
6125<a name="Cudd_bddNor"><b>Cudd_bddNor</b></a>(
6126  DdManager * <b>dd</b>, <i></i>
6127  DdNode * <b>f</b>, <i></i>
6128  DdNode * <b>g</b> <i></i>
6129)
6130</pre>
6131<dd> Computes the NOR of two BDDs f and g. Returns a pointer to the resulting BDD if successful; NULL if the intermediate result blows up.
6132<p>
6133
6134<dd> <b>Side Effects</b> None
6135<p>
6136
6137<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_bddIte">Cudd_bddIte</a>
6138<a href="cuddAllDet.html#Cudd_addApply">Cudd_addApply</a>
6139<a href="cuddAllDet.html#Cudd_bddAnd">Cudd_bddAnd</a>
6140<a href="cuddAllDet.html#Cudd_bddOr">Cudd_bddOr</a>
6141<a href="cuddAllDet.html#Cudd_bddNand">Cudd_bddNand</a>
6142<a href="cuddAllDet.html#Cudd_bddXor">Cudd_bddXor</a>
6143<a href="cuddAllDet.html#Cudd_bddXnor">Cudd_bddXnor</a>
6144</code>
6145
6146<dt><pre>
6147DdNode * <i></i>
6148<a name="Cudd_bddOr"><b>Cudd_bddOr</b></a>(
6149  DdManager * <b>dd</b>, <i></i>
6150  DdNode * <b>f</b>, <i></i>
6151  DdNode * <b>g</b> <i></i>
6152)
6153</pre>
6154<dd> Computes the disjunction of two BDDs f and g. Returns a pointer to the resulting BDD if successful; NULL if the intermediate result blows up.
6155<p>
6156
6157<dd> <b>Side Effects</b> None
6158<p>
6159
6160<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_bddIte">Cudd_bddIte</a>
6161<a href="cuddAllDet.html#Cudd_addApply">Cudd_addApply</a>
6162<a href="cuddAllDet.html#Cudd_bddAnd">Cudd_bddAnd</a>
6163<a href="cuddAllDet.html#Cudd_bddNand">Cudd_bddNand</a>
6164<a href="cuddAllDet.html#Cudd_bddNor">Cudd_bddNor</a>
6165<a href="cuddAllDet.html#Cudd_bddXor">Cudd_bddXor</a>
6166<a href="cuddAllDet.html#Cudd_bddXnor">Cudd_bddXnor</a>
6167</code>
6168
6169<dt><pre>
6170DdNode * <i></i>
6171<a name="Cudd_bddPermute"><b>Cudd_bddPermute</b></a>(
6172  DdManager * <b>manager</b>, <i></i>
6173  DdNode * <b>node</b>, <i></i>
6174  int * <b>permut</b> <i></i>
6175)
6176</pre>
6177<dd> Given a permutation in array permut, creates a new BDD with permuted variables. There should be an entry in array permut for each variable in the manager. The i-th entry of permut holds the index of the variable that is to substitute the i-th variable. Returns a pointer to the resulting BDD if successful; NULL otherwise.
6178<p>
6179
6180<dd> <b>Side Effects</b> None
6181<p>
6182
6183<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_addPermute">Cudd_addPermute</a>
6184<a href="cuddAllDet.html#Cudd_bddSwapVariables">Cudd_bddSwapVariables</a>
6185</code>
6186
6187<dt><pre>
6188DdNode ** <i></i>
6189<a name="Cudd_bddPickArbitraryMinterms"><b>Cudd_bddPickArbitraryMinterms</b></a>(
6190  DdManager * <b>dd</b>, <i>manager</i>
6191  DdNode * <b>f</b>, <i>function from which to pick k minterms</i>
6192  DdNode ** <b>vars</b>, <i>array of variables</i>
6193  int  <b>n</b>, <i>size of <code>vars</code></i>
6194  int  <b>k</b> <i>number of minterms to find</i>
6195)
6196</pre>
6197<dd> Picks k on-set minterms evenly distributed from given DD. The minterms are in terms of <code>vars</code>. The array <code>vars</code> should contain at least all variables in the support of <code>f</code>; if this condition is not met the minterms built by this procedure may not be contained in <code>f</code>. Builds an array of BDDs for the minterms and returns a pointer to it if successful; NULL otherwise. There are three reasons why the procedure may fail: <ul> <li> It may run out of memory; <li> the function <code>f</code> may be the constant 0; <li> the minterms may not be contained in <code>f</code>. </ul>
6198<p>
6199
6200<dd> <b>Side Effects</b> None
6201<p>
6202
6203<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_bddPickOneMinterm">Cudd_bddPickOneMinterm</a>
6204<a href="cuddAllDet.html#Cudd_bddPickOneCube">Cudd_bddPickOneCube</a>
6205</code>
6206
6207<dt><pre>
6208int <i></i>
6209<a name="Cudd_bddPickOneCube"><b>Cudd_bddPickOneCube</b></a>(
6210  DdManager * <b>ddm</b>, <i></i>
6211  DdNode * <b>node</b>, <i></i>
6212  char * <b>string</b> <i></i>
6213)
6214</pre>
6215<dd> Picks one on-set cube randomly from the given DD. The cube is written into an array of characters. The array must have at least as many entries as there are variables. Returns 1 if successful; 0 otherwise.
6216<p>
6217
6218<dd> <b>Side Effects</b> None
6219<p>
6220
6221<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_bddPickOneMinterm">Cudd_bddPickOneMinterm</a>
6222</code>
6223
6224<dt><pre>
6225DdNode * <i></i>
6226<a name="Cudd_bddPickOneMinterm"><b>Cudd_bddPickOneMinterm</b></a>(
6227  DdManager * <b>dd</b>, <i>manager</i>
6228  DdNode * <b>f</b>, <i>function from which to pick one minterm</i>
6229  DdNode ** <b>vars</b>, <i>array of variables</i>
6230  int  <b>n</b> <i>size of <code>vars</code></i>
6231)
6232</pre>
6233<dd> Picks one on-set minterm randomly from the given DD. The minterm is in terms of <code>vars</code>. The array <code>vars</code> should contain at least all variables in the support of <code>f</code>; if this condition is not met the minterm built by this procedure may not be contained in <code>f</code>. Builds a BDD for the minterm and returns a pointer to it if successful; NULL otherwise. There are three reasons why the procedure may fail: <ul> <li> It may run out of memory; <li> the function <code>f</code> may be the constant 0; <li> the minterm may not be contained in <code>f</code>. </ul>
6234<p>
6235
6236<dd> <b>Side Effects</b> None
6237<p>
6238
6239<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_bddPickOneCube">Cudd_bddPickOneCube</a>
6240</code>
6241
6242<dt><pre>
6243int <i></i>
6244<a name="Cudd_bddPrintCover"><b>Cudd_bddPrintCover</b></a>(
6245  DdManager * <b>dd</b>, <i></i>
6246  DdNode * <b>l</b>, <i></i>
6247  DdNode * <b>u</b> <i></i>
6248)
6249</pre>
6250<dd> Prints a sum of product cover for an incompletely specified function given by a lower bound and an upper bound. Each product is a prime implicant obtained by expanding the product corresponding to a path from node to the constant one. Uses the package default output file. Returns 1 if successful; 0 otherwise.
6251<p>
6252
6253<dd> <b>Side Effects</b> None
6254<p>
6255
6256<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_PrintMinterm">Cudd_PrintMinterm</a>
6257</code>
6258
6259<dt><pre>
6260int <i></i>
6261<a name="Cudd_bddReadPairIndex"><b>Cudd_bddReadPairIndex</b></a>(
6262  DdManager * <b>dd</b>, <i></i>
6263  int  <b>index</b> <i></i>
6264)
6265</pre>
6266<dd> Reads a corresponding pair index for a given index. These pair indices are present and next state variable. Returns the corresponding variable index if the variable exists; -1 otherwise.
6267<p>
6268
6269<dd> <b>Side Effects</b> modifies the manager
6270<p>
6271
6272<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_bddSetPairIndex">Cudd_bddSetPairIndex</a>
6273</code>
6274
6275<dt><pre>
6276int <i></i>
6277<a name="Cudd_bddRead"><b>Cudd_bddRead</b></a>(
6278  FILE * <b>fp</b>, <i>input file pointer</i>
6279  DdManager * <b>dd</b>, <i>DD manager</i>
6280  DdNode ** <b>E</b>, <i>characteristic function of the graph</i>
6281  DdNode *** <b>x</b>, <i>array of row variables</i>
6282  DdNode *** <b>y</b>, <i>array of column variables</i>
6283  int * <b>nx</b>, <i>number or row variables</i>
6284  int * <b>ny</b>, <i>number or column variables</i>
6285  int * <b>m</b>, <i>number of rows</i>
6286  int * <b>n</b>, <i>number of columns</i>
6287  int  <b>bx</b>, <i>first index of row variables</i>
6288  int  <b>sx</b>, <i>step of row variables</i>
6289  int  <b>by</b>, <i>first index of column variables</i>
6290  int  <b>sy</b> <i>step of column variables</i>
6291)
6292</pre>
6293<dd> Reads in a graph (without labels) given as an adjacency matrix. The first line of the input contains the numbers of rows and columns of the adjacency matrix. The remaining lines contain the arcs of the graph, one per line. Each arc is described by two integers, i.e., the row and column number, or the indices of the two endpoints. Cudd_bddRead produces a BDD that depends on two sets of variables: x and y. The x variables (x[0] ... x[nx-1]) encode the row index and the y variables (y[0] ... y[ny-1]) encode the column index. x[0] and y[0] are the most significant bits in the indices. The variables may already exist or may be created by the function. The index of x[i] is bx+i*sx, and the index of y[i] is by+i*sy.<p> On input, nx and ny hold the numbers of row and column variables already in existence. On output, they hold the numbers of row and column variables actually used by the matrix. When Cudd_bddRead creates the variable arrays, the index of x[i] is bx+i*sx, and the index of y[i] is by+i*sy. When some variables already exist, Cudd_bddRead expects the indices of the existing x variables to be bx+i*sx, and the indices of the existing y variables to be by+i*sy.<p> m and n are set to the numbers of rows and columns of the matrix. Their values on input are immaterial. The BDD for the graph is returned in E, and its reference count is > 0. Cudd_bddRead returns 1 in case of success; 0 otherwise.
6294<p>
6295
6296<dd> <b>Side Effects</b> nx and ny are set to the numbers of row and column variables. m and n are set to the numbers of rows and columns. x and y are possibly extended to represent the array of row and column variables.
6297<p>
6298
6299<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_addHarwell">Cudd_addHarwell</a>
6300<a href="cuddAllDet.html#Cudd_addRead">Cudd_addRead</a>
6301</code>
6302
6303<dt><pre>
6304void <i></i>
6305<a name="Cudd_bddRealignDisable"><b>Cudd_bddRealignDisable</b></a>(
6306  DdManager * <b>unique</b> <i></i>
6307)
6308</pre>
6309<dd> Disables realignment of ZDD order to BDD order.
6310<p>
6311
6312<dd> <b>Side Effects</b> None
6313<p>
6314
6315<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_bddRealignEnable">Cudd_bddRealignEnable</a>
6316<a href="cuddAllDet.html#Cudd_bddRealignmentEnabled">Cudd_bddRealignmentEnabled</a>
6317<a href="cuddAllDet.html#Cudd_zddRealignEnable">Cudd_zddRealignEnable</a>
6318<a href="cuddAllDet.html#Cudd_zddRealignmentEnabled">Cudd_zddRealignmentEnabled</a>
6319</code>
6320
6321<dt><pre>
6322void <i></i>
6323<a name="Cudd_bddRealignEnable"><b>Cudd_bddRealignEnable</b></a>(
6324  DdManager * <b>unique</b> <i></i>
6325)
6326</pre>
6327<dd> 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.
6328<p>
6329
6330<dd> <b>Side Effects</b> None
6331<p>
6332
6333<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_zddReduceHeap">Cudd_zddReduceHeap</a>
6334<a href="cuddAllDet.html#Cudd_bddRealignDisable">Cudd_bddRealignDisable</a>
6335<a href="cuddAllDet.html#Cudd_bddRealignmentEnabled">Cudd_bddRealignmentEnabled</a>
6336<a href="cuddAllDet.html#Cudd_zddRealignDisable">Cudd_zddRealignDisable</a>
6337<a href="cuddAllDet.html#Cudd_zddRealignmentEnabled">Cudd_zddRealignmentEnabled</a>
6338</code>
6339
6340<dt><pre>
6341int <i></i>
6342<a name="Cudd_bddRealignmentEnabled"><b>Cudd_bddRealignmentEnabled</b></a>(
6343  DdManager * <b>unique</b> <i></i>
6344)
6345</pre>
6346<dd> Returns 1 if the realignment of BDD order to ZDD order is enabled; 0 otherwise.
6347<p>
6348
6349<dd> <b>Side Effects</b> None
6350<p>
6351
6352<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_bddRealignEnable">Cudd_bddRealignEnable</a>
6353<a href="cuddAllDet.html#Cudd_bddRealignDisable">Cudd_bddRealignDisable</a>
6354<a href="cuddAllDet.html#Cudd_zddRealignEnable">Cudd_zddRealignEnable</a>
6355<a href="cuddAllDet.html#Cudd_zddRealignDisable">Cudd_zddRealignDisable</a>
6356</code>
6357
6358<dt><pre>
6359int <i></i>
6360<a name="Cudd_bddResetVarToBeGrouped"><b>Cudd_bddResetVarToBeGrouped</b></a>(
6361  DdManager * <b>dd</b>, <i></i>
6362  int  <b>index</b> <i></i>
6363)
6364</pre>
6365<dd> Resets a variable not to be grouped. This function is used for lazy sifting. Returns 1 if successful; 0 otherwise.
6366<p>
6367
6368<dd> <b>Side Effects</b> modifies the manager
6369<p>
6370
6371<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_bddSetVarToBeGrouped">Cudd_bddSetVarToBeGrouped</a>
6372<a href="cuddAllDet.html#Cudd_bddSetVarHardGroup">Cudd_bddSetVarHardGroup</a>
6373</code>
6374
6375<dt><pre>
6376DdNode * <i></i>
6377<a name="Cudd_bddRestrict"><b>Cudd_bddRestrict</b></a>(
6378  DdManager * <b>dd</b>, <i></i>
6379  DdNode * <b>f</b>, <i></i>
6380  DdNode * <b>c</b> <i></i>
6381)
6382</pre>
6383<dd> BDD restrict according to Coudert and Madre's algorithm (ICCAD90). Returns the restricted BDD if successful; otherwise NULL. If application of restrict results in a BDD larger than the input BDD, the input BDD is returned.
6384<p>
6385
6386<dd> <b>Side Effects</b> None
6387<p>
6388
6389<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_bddConstrain">Cudd_bddConstrain</a>
6390<a href="cuddAllDet.html#Cudd_addRestrict">Cudd_addRestrict</a>
6391</code>
6392
6393<dt><pre>
6394int <i></i>
6395<a name="Cudd_bddSetNsVar"><b>Cudd_bddSetNsVar</b></a>(
6396  DdManager * <b>dd</b>, <i>manager</i>
6397  int  <b>index</b> <i>variable index</i>
6398)
6399</pre>
6400<dd> Sets a variable type to next state. The variable type is used by lazy sifting. Returns 1 if successful; 0 otherwise.
6401<p>
6402
6403<dd> <b>Side Effects</b> modifies the manager
6404<p>
6405
6406<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_bddSetPiVar">Cudd_bddSetPiVar</a>
6407<a href="cuddAllDet.html#Cudd_bddSetPsVar">Cudd_bddSetPsVar</a>
6408<a href="cuddAllDet.html#Cudd_bddIsNsVar">Cudd_bddIsNsVar</a>
6409</code>
6410
6411<dt><pre>
6412int <i></i>
6413<a name="Cudd_bddSetPairIndex"><b>Cudd_bddSetPairIndex</b></a>(
6414  DdManager * <b>dd</b>, <i>manager</i>
6415  int  <b>index</b>, <i>variable index</i>
6416  int  <b>pairIndex</b> <i>corresponding variable index</i>
6417)
6418</pre>
6419<dd> Sets a corresponding pair index for a given index. These pair indices are present and next state variable. Returns 1 if successful; 0 otherwise.
6420<p>
6421
6422<dd> <b>Side Effects</b> modifies the manager
6423<p>
6424
6425<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_bddReadPairIndex">Cudd_bddReadPairIndex</a>
6426</code>
6427
6428<dt><pre>
6429int <i></i>
6430<a name="Cudd_bddSetPiVar"><b>Cudd_bddSetPiVar</b></a>(
6431  DdManager * <b>dd</b>, <i>manager</i>
6432  int  <b>index</b> <i>variable index</i>
6433)
6434</pre>
6435<dd> Sets a variable type to primary input. The variable type is used by lazy sifting. Returns 1 if successful; 0 otherwise.
6436<p>
6437
6438<dd> <b>Side Effects</b> modifies the manager
6439<p>
6440
6441<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_bddSetPsVar">Cudd_bddSetPsVar</a>
6442<a href="cuddAllDet.html#Cudd_bddSetNsVar">Cudd_bddSetNsVar</a>
6443<a href="cuddAllDet.html#Cudd_bddIsPiVar">Cudd_bddIsPiVar</a>
6444</code>
6445
6446<dt><pre>
6447int <i></i>
6448<a name="Cudd_bddSetPsVar"><b>Cudd_bddSetPsVar</b></a>(
6449  DdManager * <b>dd</b>, <i>manager</i>
6450  int  <b>index</b> <i>variable index</i>
6451)
6452</pre>
6453<dd> Sets a variable type to present state. The variable type is used by lazy sifting. Returns 1 if successful; 0 otherwise.
6454<p>
6455
6456<dd> <b>Side Effects</b> modifies the manager
6457<p>
6458
6459<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_bddSetPiVar">Cudd_bddSetPiVar</a>
6460<a href="cuddAllDet.html#Cudd_bddSetNsVar">Cudd_bddSetNsVar</a>
6461<a href="cuddAllDet.html#Cudd_bddIsPsVar">Cudd_bddIsPsVar</a>
6462</code>
6463
6464<dt><pre>
6465int <i></i>
6466<a name="Cudd_bddSetVarHardGroup"><b>Cudd_bddSetVarHardGroup</b></a>(
6467  DdManager * <b>dd</b>, <i></i>
6468  int  <b>index</b> <i></i>
6469)
6470</pre>
6471<dd> Sets a variable to be a hard group. This function is used for lazy sifting. Returns 1 if successful; 0 otherwise.
6472<p>
6473
6474<dd> <b>Side Effects</b> modifies the manager
6475<p>
6476
6477<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_bddSetVarToBeGrouped">Cudd_bddSetVarToBeGrouped</a>
6478<a href="cuddAllDet.html#Cudd_bddResetVarToBeGrouped">Cudd_bddResetVarToBeGrouped</a>
6479<a href="cuddAllDet.html#Cudd_bddIsVarHardGroup">Cudd_bddIsVarHardGroup</a>
6480</code>
6481
6482<dt><pre>
6483int <i></i>
6484<a name="Cudd_bddSetVarToBeGrouped"><b>Cudd_bddSetVarToBeGrouped</b></a>(
6485  DdManager * <b>dd</b>, <i></i>
6486  int  <b>index</b> <i></i>
6487)
6488</pre>
6489<dd> Sets a variable to be grouped. This function is used for lazy sifting. Returns 1 if successful; 0 otherwise.
6490<p>
6491
6492<dd> <b>Side Effects</b> modifies the manager
6493<p>
6494
6495<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_bddSetVarHardGroup">Cudd_bddSetVarHardGroup</a>
6496<a href="cuddAllDet.html#Cudd_bddResetVarToBeGrouped">Cudd_bddResetVarToBeGrouped</a>
6497</code>
6498
6499<dt><pre>
6500int <i></i>
6501<a name="Cudd_bddSetVarToBeUngrouped"><b>Cudd_bddSetVarToBeUngrouped</b></a>(
6502  DdManager * <b>dd</b>, <i></i>
6503  int  <b>index</b> <i></i>
6504)
6505</pre>
6506<dd> Sets a variable to be ungrouped. This function is used for lazy sifting. Returns 1 if successful; 0 otherwise.
6507<p>
6508
6509<dd> <b>Side Effects</b> modifies the manager
6510<p>
6511
6512<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_bddIsVarToBeUngrouped">Cudd_bddIsVarToBeUngrouped</a>
6513</code>
6514
6515<dt><pre>
6516DdNode * <i></i>
6517<a name="Cudd_bddSqueeze"><b>Cudd_bddSqueeze</b></a>(
6518  DdManager * <b>dd</b>, <i>manager</i>
6519  DdNode * <b>l</b>, <i>lower bound</i>
6520  DdNode * <b>u</b> <i>upper bound</i>
6521)
6522</pre>
6523<dd> Finds a small BDD in a function interval. Given BDDs <code>l</code> and <code>u</code>, representing the lower bound and upper bound of a function interval, Cudd_bddSqueeze produces the BDD of a function within the interval with a small BDD. Returns a pointer to the result if successful; NULL otherwise.
6524<p>
6525
6526<dd> <b>Side Effects</b> None
6527<p>
6528
6529<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_bddRestrict">Cudd_bddRestrict</a>
6530<a href="cuddAllDet.html#Cudd_bddLICompaction">Cudd_bddLICompaction</a>
6531</code>
6532
6533<dt><pre>
6534DdNode * <i></i>
6535<a name="Cudd_bddSwapVariables"><b>Cudd_bddSwapVariables</b></a>(
6536  DdManager * <b>dd</b>, <i></i>
6537  DdNode * <b>f</b>, <i></i>
6538  DdNode ** <b>x</b>, <i></i>
6539  DdNode ** <b>y</b>, <i></i>
6540  int  <b>n</b> <i></i>
6541)
6542</pre>
6543<dd> Swaps two sets of variables of the same size (x and y) in the BDD f. The size is given by n. The two sets of variables are assumed to be disjoint. Returns a pointer to the resulting BDD if successful; NULL otherwise.
6544<p>
6545
6546<dd> <b>Side Effects</b> None
6547<p>
6548
6549<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_bddPermute">Cudd_bddPermute</a>
6550<a href="cuddAllDet.html#Cudd_addSwapVariables">Cudd_addSwapVariables</a>
6551</code>
6552
6553<dt><pre>
6554DdNode * <i></i>
6555<a name="Cudd_bddTransfer"><b>Cudd_bddTransfer</b></a>(
6556  DdManager * <b>ddSource</b>, <i></i>
6557  DdManager * <b>ddDestination</b>, <i></i>
6558  DdNode * <b>f</b> <i></i>
6559)
6560</pre>
6561<dd> Convert a BDD from a manager to another one. The orders of the variables in the two managers may be different. Returns a pointer to the BDD in the destination manager if successful; NULL otherwise.
6562<p>
6563
6564<dd> <b>Side Effects</b> None
6565<p>
6566
6567<dt><pre>
6568int <i></i>
6569<a name="Cudd_bddUnbindVar"><b>Cudd_bddUnbindVar</b></a>(
6570  DdManager * <b>dd</b>, <i>manager</i>
6571  int  <b>index</b> <i>variable index</i>
6572)
6573</pre>
6574<dd> 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. Returns 1 if successful; 0 otherwise (i.e., invalid variable index).
6575<p>
6576
6577<dd> <b>Side Effects</b> Changes the "bindVar" flag in DdSubtable.
6578<p>
6579
6580<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_bddBindVar">Cudd_bddBindVar</a>
6581</code>
6582
6583<dt><pre>
6584DdNode * <i></i>
6585<a name="Cudd_bddUnivAbstract"><b>Cudd_bddUnivAbstract</b></a>(
6586  DdManager * <b>manager</b>, <i></i>
6587  DdNode * <b>f</b>, <i></i>
6588  DdNode * <b>cube</b> <i></i>
6589)
6590</pre>
6591<dd> Universally abstracts all the variables in cube from f. Returns the abstracted BDD if successful; NULL otherwise.
6592<p>
6593
6594<dd> <b>Side Effects</b> None
6595<p>
6596
6597<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_bddExistAbstract">Cudd_bddExistAbstract</a>
6598<a href="cuddAllDet.html#Cudd_addUnivAbstract">Cudd_addUnivAbstract</a>
6599</code>
6600
6601<dt><pre>
6602int <i></i>
6603<a name="Cudd_bddVarConjDecomp"><b>Cudd_bddVarConjDecomp</b></a>(
6604  DdManager * <b>dd</b>, <i>manager</i>
6605  DdNode * <b>f</b>, <i>function to be decomposed</i>
6606  DdNode *** <b>conjuncts</b> <i>address of the array of conjuncts</i>
6607)
6608</pre>
6609<dd> Conjunctively decomposes one BDD according to a variable. If <code>f</code> is the function of the BDD and <code>x</code> is the variable, the decomposition is <code>(f+x)(f+x')</code>. The variable is chosen so as to balance the sizes of the two conjuncts and to keep them small. Returns the number of conjuncts produced, that is, 2 if successful; 1 if no meaningful decomposition was found; 0 otherwise.
6610<p>
6611
6612<dd> <b>Side Effects</b> The two factors are returned in an array as side effects. The array is allocated by this function. It is the caller's responsibility to free it. On successful completion, the conjuncts are already referenced. If the function returns 0, the array for the conjuncts is not allocated. If the function returns 1, the only factor equals the function to be decomposed.
6613<p>
6614
6615<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_bddVarDisjDecomp">Cudd_bddVarDisjDecomp</a>
6616<a href="cuddAllDet.html#Cudd_bddGenConjDecomp">Cudd_bddGenConjDecomp</a>
6617<a href="cuddAllDet.html#Cudd_bddApproxConjDecomp">Cudd_bddApproxConjDecomp</a>
6618<a href="cuddAllDet.html#Cudd_bddIterConjDecomp">Cudd_bddIterConjDecomp</a>
6619</code>
6620
6621<dt><pre>
6622int <i></i>
6623<a name="Cudd_bddVarDisjDecomp"><b>Cudd_bddVarDisjDecomp</b></a>(
6624  DdManager * <b>dd</b>, <i>manager</i>
6625  DdNode * <b>f</b>, <i>function to be decomposed</i>
6626  DdNode *** <b>disjuncts</b> <i>address of the array of the disjuncts</i>
6627)
6628</pre>
6629<dd> Performs two-way disjunctive decomposition of a BDD according to a variable. If <code>f</code> is the function of the BDD and <code>x</code> is the variable, the decomposition is <code>f*x + f*x'</code>. The variable is chosen so as to balance the sizes of the two disjuncts and to keep them small. Returns the number of disjuncts produced, that is, 2 if successful; 1 if no meaningful decomposition was found; 0 otherwise.
6630<p>
6631
6632<dd> <b>Side Effects</b> The two disjuncts are returned in an array as side effects. The array is allocated by this function. It is the caller's responsibility to free it. On successful completion, the disjuncts are already referenced. If the function returns 0, the array for the disjuncts is not allocated. If the function returns 1, the only factor equals the function to be decomposed.
6633<p>
6634
6635<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_bddVarConjDecomp">Cudd_bddVarConjDecomp</a>
6636<a href="cuddAllDet.html#Cudd_bddApproxDisjDecomp">Cudd_bddApproxDisjDecomp</a>
6637<a href="cuddAllDet.html#Cudd_bddIterDisjDecomp">Cudd_bddIterDisjDecomp</a>
6638<a href="cuddAllDet.html#Cudd_bddGenDisjDecomp">Cudd_bddGenDisjDecomp</a>
6639</code>
6640
6641<dt><pre>
6642int <i></i>
6643<a name="Cudd_bddVarIsBound"><b>Cudd_bddVarIsBound</b></a>(
6644  DdManager * <b>dd</b>, <i>manager</i>
6645  int  <b>index</b> <i>variable index</i>
6646)
6647</pre>
6648<dd> This function returns 1 if a variable is enabled for sifting. Initially all variables can be sifted. This function returns 0 only 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.
6649<p>
6650
6651<dd> <b>Side Effects</b> none
6652<p>
6653
6654<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_bddBindVar">Cudd_bddBindVar</a>
6655<a href="cuddAllDet.html#Cudd_bddUnbindVar">Cudd_bddUnbindVar</a>
6656</code>
6657
6658<dt><pre>
6659int <i></i>
6660<a name="Cudd_bddVarIsDependent"><b>Cudd_bddVarIsDependent</b></a>(
6661  DdManager * <b>dd</b>, <i></i>
6662  DdNode * <b>f</b>, <i></i>
6663  DdNode * <b>var</b> <i>variable</i>
6664)
6665</pre>
6666<dd> Checks whether a variable is dependent on others in a function. Returns 1 if the variable is dependent; 0 otherwise. No new nodes are created.
6667<p>
6668
6669<dd> <b>Side Effects</b> None
6670<p>
6671
6672<dt><pre>
6673DdNode * <i></i>
6674<a name="Cudd_bddVarMap"><b>Cudd_bddVarMap</b></a>(
6675  DdManager * <b>manager</b>, <i>DD manager</i>
6676  DdNode * <b>f</b> <i>function in which to remap variables</i>
6677)
6678</pre>
6679<dd> Remaps the variables of a BDD using the default variable map. A typical use of this function is to swap two sets of variables. The variable map must be registered with Cudd_SetVarMap. Returns a pointer to the resulting BDD if successful; NULL otherwise.
6680<p>
6681
6682<dd> <b>Side Effects</b> None
6683<p>
6684
6685<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_bddPermute">Cudd_bddPermute</a>
6686<a href="cuddAllDet.html#Cudd_bddSwapVariables">Cudd_bddSwapVariables</a>
6687<a href="cuddAllDet.html#Cudd_SetVarMap">Cudd_SetVarMap</a>
6688</code>
6689
6690<dt><pre>
6691DdNode * <i></i>
6692<a name="Cudd_bddVectorCompose"><b>Cudd_bddVectorCompose</b></a>(
6693  DdManager * <b>dd</b>, <i></i>
6694  DdNode * <b>f</b>, <i></i>
6695  DdNode ** <b>vector</b> <i></i>
6696)
6697</pre>
6698<dd> Given a vector of BDDs, creates a new BDD by substituting the BDDs for the variables of the BDD f. There should be an entry in vector for each variable in the manager. If no substitution is sought for a given variable, the corresponding projection function should be specified in the vector. This function implements simultaneous composition. Returns a pointer to the resulting BDD if successful; NULL otherwise.
6699<p>
6700
6701<dd> <b>Side Effects</b> None
6702<p>
6703
6704<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_bddPermute">Cudd_bddPermute</a>
6705<a href="cuddAllDet.html#Cudd_bddCompose">Cudd_bddCompose</a>
6706<a href="cuddAllDet.html#Cudd_addVectorCompose">Cudd_addVectorCompose</a>
6707</code>
6708
6709<dt><pre>
6710DdNode * <i></i>
6711<a name="Cudd_bddXnor"><b>Cudd_bddXnor</b></a>(
6712  DdManager * <b>dd</b>, <i></i>
6713  DdNode * <b>f</b>, <i></i>
6714  DdNode * <b>g</b> <i></i>
6715)
6716</pre>
6717<dd> Computes the exclusive NOR of two BDDs f and g. Returns a pointer to the resulting BDD if successful; NULL if the intermediate result blows up.
6718<p>
6719
6720<dd> <b>Side Effects</b> None
6721<p>
6722
6723<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_bddIte">Cudd_bddIte</a>
6724<a href="cuddAllDet.html#Cudd_addApply">Cudd_addApply</a>
6725<a href="cuddAllDet.html#Cudd_bddAnd">Cudd_bddAnd</a>
6726<a href="cuddAllDet.html#Cudd_bddOr">Cudd_bddOr</a>
6727<a href="cuddAllDet.html#Cudd_bddNand">Cudd_bddNand</a>
6728<a href="cuddAllDet.html#Cudd_bddNor">Cudd_bddNor</a>
6729<a href="cuddAllDet.html#Cudd_bddXor">Cudd_bddXor</a>
6730</code>
6731
6732<dt><pre>
6733DdNode * <i></i>
6734<a name="Cudd_bddXorExistAbstract"><b>Cudd_bddXorExistAbstract</b></a>(
6735  DdManager * <b>manager</b>, <i></i>
6736  DdNode * <b>f</b>, <i></i>
6737  DdNode * <b>g</b>, <i></i>
6738  DdNode * <b>cube</b> <i></i>
6739)
6740</pre>
6741<dd> Takes the exclusive OR of two BDDs and simultaneously abstracts the variables in cube. The variables are existentially abstracted. Returns a pointer to the result is successful; NULL otherwise.
6742<p>
6743
6744<dd> <b>Side Effects</b> None
6745<p>
6746
6747<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_bddUnivAbstract">Cudd_bddUnivAbstract</a>
6748<a href="cuddAllDet.html#Cudd_bddExistAbstract">Cudd_bddExistAbstract</a>
6749<a href="cuddAllDet.html#Cudd_bddAndAbstract">Cudd_bddAndAbstract</a>
6750</code>
6751
6752<dt><pre>
6753DdNode * <i></i>
6754<a name="Cudd_bddXor"><b>Cudd_bddXor</b></a>(
6755  DdManager * <b>dd</b>, <i></i>
6756  DdNode * <b>f</b>, <i></i>
6757  DdNode * <b>g</b> <i></i>
6758)
6759</pre>
6760<dd> Computes the exclusive OR of two BDDs f and g. Returns a pointer to the resulting BDD if successful; NULL if the intermediate result blows up.
6761<p>
6762
6763<dd> <b>Side Effects</b> None
6764<p>
6765
6766<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_bddIte">Cudd_bddIte</a>
6767<a href="cuddAllDet.html#Cudd_addApply">Cudd_addApply</a>
6768<a href="cuddAllDet.html#Cudd_bddAnd">Cudd_bddAnd</a>
6769<a href="cuddAllDet.html#Cudd_bddOr">Cudd_bddOr</a>
6770<a href="cuddAllDet.html#Cudd_bddNand">Cudd_bddNand</a>
6771<a href="cuddAllDet.html#Cudd_bddNor">Cudd_bddNor</a>
6772<a href="cuddAllDet.html#Cudd_bddXnor">Cudd_bddXnor</a>
6773</code>
6774
6775<dt><pre>
6776void <i></i>
6777<a name="Cudd_tlcInfoFree"><b>Cudd_tlcInfoFree</b></a>(
6778  DdTlcInfo * <b>t</b> <i></i>
6779)
6780</pre>
6781<dd> Frees a DdTlcInfo Structure as well as the memory pointed by it.
6782<p>
6783
6784<dd> <b>Side Effects</b> None
6785<p>
6786
6787<dt><pre>
6788DdNode * <i></i>
6789<a name="Cudd_zddChange"><b>Cudd_zddChange</b></a>(
6790  DdManager * <b>dd</b>, <i></i>
6791  DdNode * <b>P</b>, <i></i>
6792  int  <b>var</b> <i></i>
6793)
6794</pre>
6795<dd> Substitutes a variable with its complement in a ZDD. returns a pointer to the result if successful; NULL otherwise.
6796<p>
6797
6798<dd> <b>Side Effects</b> None
6799<p>
6800
6801<dt><pre>
6802DdNode  * <i></i>
6803<a name="Cudd_zddComplement"><b>Cudd_zddComplement</b></a>(
6804  DdManager * <b>dd</b>, <i></i>
6805  DdNode * <b>node</b> <i></i>
6806)
6807</pre>
6808<dd> Computes a complement cover for a ZDD node. For lack of a better method, we first extract the function BDD from the ZDD cover, then make the complement of the ZDD cover from the complement of the BDD node by using ISOP. Returns a pointer to the resulting cover if successful; NULL otherwise. The result depends on current variable order.
6809<p>
6810
6811<dd> <b>Side Effects</b> The result depends on current variable order.
6812<p>
6813
6814<dt><pre>
6815double <i></i>
6816<a name="Cudd_zddCountDouble"><b>Cudd_zddCountDouble</b></a>(
6817  DdManager * <b>zdd</b>, <i></i>
6818  DdNode * <b>P</b> <i></i>
6819)
6820</pre>
6821<dd> Counts the number of minterms of a ZDD. The result is returned as a double. If the procedure runs out of memory, it returns (double) CUDD_OUT_OF_MEM. This procedure is used in Cudd_zddCountMinterm.
6822<p>
6823
6824<dd> <b>Side Effects</b> None
6825<p>
6826
6827<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_zddCountMinterm">Cudd_zddCountMinterm</a>
6828<a href="cuddAllDet.html#Cudd_zddCount">Cudd_zddCount</a>
6829</code>
6830
6831<dt><pre>
6832double <i></i>
6833<a name="Cudd_zddCountMinterm"><b>Cudd_zddCountMinterm</b></a>(
6834  DdManager * <b>zdd</b>, <i></i>
6835  DdNode * <b>node</b>, <i></i>
6836  int  <b>path</b> <i></i>
6837)
6838</pre>
6839<dd> Counts the number of minterms of the ZDD rooted at <code>node</code>. This procedure takes a parameter <code>path</code> that specifies how many variables are in the support of the function. If the procedure runs out of memory, it returns (double) CUDD_OUT_OF_MEM.
6840<p>
6841
6842<dd> <b>Side Effects</b> None
6843<p>
6844
6845<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_zddCountDouble">Cudd_zddCountDouble</a>
6846</code>
6847
6848<dt><pre>
6849int <i></i>
6850<a name="Cudd_zddCount"><b>Cudd_zddCount</b></a>(
6851  DdManager * <b>zdd</b>, <i></i>
6852  DdNode * <b>P</b> <i></i>
6853)
6854</pre>
6855<dd> Returns an integer representing the number of minterms in a ZDD.
6856<p>
6857
6858<dd> <b>Side Effects</b> None
6859<p>
6860
6861<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_zddCountDouble">Cudd_zddCountDouble</a>
6862</code>
6863
6864<dt><pre>
6865char * <i></i>
6866<a name="Cudd_zddCoverPathToString"><b>Cudd_zddCoverPathToString</b></a>(
6867  DdManager * <b>zdd</b>, <i>DD manager</i>
6868  int * <b>path</b>, <i>path of ZDD representing a cover</i>
6869  char * <b>str</b> <i>pointer to string to use if != NULL</i>
6870)
6871</pre>
6872<dd> Converts a path of a ZDD representing a cover to a string. The string represents an implicant of the cover. The path is typically produced by Cudd_zddForeachPath. Returns a pointer to the string if successful; NULL otherwise. If the str input is NULL, it allocates a new string. The string passed to this function must have enough room for all variables and for the terminator.
6873<p>
6874
6875<dd> <b>Side Effects</b> None
6876<p>
6877
6878<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_zddForeachPath">Cudd_zddForeachPath</a>
6879</code>
6880
6881<dt><pre>
6882int <i></i>
6883<a name="Cudd_zddDagSize"><b>Cudd_zddDagSize</b></a>(
6884  DdNode * <b>p_node</b> <i></i>
6885)
6886</pre>
6887<dd> Counts the number of nodes in a ZDD. This function duplicates Cudd_DagSize and is only retained for compatibility.
6888<p>
6889
6890<dd> <b>Side Effects</b> None
6891<p>
6892
6893<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_DagSize">Cudd_DagSize</a>
6894</code>
6895
6896<dt><pre>
6897DdNode * <i></i>
6898<a name="Cudd_zddDiffConst"><b>Cudd_zddDiffConst</b></a>(
6899  DdManager * <b>zdd</b>, <i></i>
6900  DdNode * <b>P</b>, <i></i>
6901  DdNode * <b>Q</b> <i></i>
6902)
6903</pre>
6904<dd> Inclusion test for ZDDs (P implies Q). No new nodes are generated by this procedure. Returns empty if true; a valid pointer different from empty or DD_NON_CONSTANT otherwise.
6905<p>
6906
6907<dd> <b>Side Effects</b> None
6908<p>
6909
6910<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_zddDiff">Cudd_zddDiff</a>
6911</code>
6912
6913<dt><pre>
6914DdNode * <i></i>
6915<a name="Cudd_zddDiff"><b>Cudd_zddDiff</b></a>(
6916  DdManager * <b>dd</b>, <i></i>
6917  DdNode * <b>P</b>, <i></i>
6918  DdNode * <b>Q</b> <i></i>
6919)
6920</pre>
6921<dd> Computes the difference of two ZDDs. Returns a pointer to the result if successful; NULL otherwise.
6922<p>
6923
6924<dd> <b>Side Effects</b> None
6925<p>
6926
6927<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_zddDiffConst">Cudd_zddDiffConst</a>
6928</code>
6929
6930<dt><pre>
6931DdNode  * <i></i>
6932<a name="Cudd_zddDivideF"><b>Cudd_zddDivideF</b></a>(
6933  DdManager * <b>dd</b>, <i></i>
6934  DdNode * <b>f</b>, <i></i>
6935  DdNode * <b>g</b> <i></i>
6936)
6937</pre>
6938<dd> Modified version of Cudd_zddDivide. This function may disappear in future releases.
6939<p>
6940
6941<dd> <b>Side Effects</b> None
6942<p>
6943
6944<dt><pre>
6945DdNode  * <i></i>
6946<a name="Cudd_zddDivide"><b>Cudd_zddDivide</b></a>(
6947  DdManager * <b>dd</b>, <i></i>
6948  DdNode * <b>f</b>, <i></i>
6949  DdNode * <b>g</b> <i></i>
6950)
6951</pre>
6952<dd> Computes the quotient of two unate covers represented by ZDDs. Unate covers use one ZDD variable for each BDD variable. Returns a pointer to the resulting ZDD if successful; NULL otherwise.
6953<p>
6954
6955<dd> <b>Side Effects</b> None
6956<p>
6957
6958<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_zddWeakDiv">Cudd_zddWeakDiv</a>
6959</code>
6960
6961<dt><pre>
6962int <i></i>
6963<a name="Cudd_zddDumpDot"><b>Cudd_zddDumpDot</b></a>(
6964  DdManager * <b>dd</b>, <i>manager</i>
6965  int  <b>n</b>, <i>number of output nodes to be dumped</i>
6966  DdNode ** <b>f</b>, <i>array of output nodes to be dumped</i>
6967  char ** <b>inames</b>, <i>array of input names (or NULL)</i>
6968  char ** <b>onames</b>, <i>array of output names (or NULL)</i>
6969  FILE * <b>fp</b> <i>pointer to the dump file</i>
6970)
6971</pre>
6972<dd> Writes a file representing the argument ZDDs in a format suitable for the graph drawing program dot. It returns 1 in case of success; 0 otherwise (e.g., out-of-memory, file system full). Cudd_zddDumpDot does not close the file: This is the caller responsibility. Cudd_zddDumpDot uses a minimal unique subset of the hexadecimal address of a node as name for it. If the argument inames is non-null, it is assumed to hold the pointers to the names of the inputs. Similarly for onames. Cudd_zddDumpDot uses the following convention to draw arcs: <ul> <li> solid line: THEN arcs; <li> dashed line: ELSE arcs. </ul> The dot options are chosen so that the drawing fits on a letter-size sheet.
6973<p>
6974
6975<dd> <b>Side Effects</b> None
6976<p>
6977
6978<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_DumpDot">Cudd_DumpDot</a>
6979<a href="cuddAllDet.html#Cudd_zddPrintDebug">Cudd_zddPrintDebug</a>
6980</code>
6981
6982<dt><pre>
6983DdGen * <i></i>
6984<a name="Cudd_zddFirstPath"><b>Cudd_zddFirstPath</b></a>(
6985  DdManager * <b>zdd</b>, <i></i>
6986  DdNode * <b>f</b>, <i></i>
6987  int ** <b>path</b> <i></i>
6988)
6989</pre>
6990<dd> Defines an iterator on the paths of a ZDD and finds its first path. Returns a generator that contains the information necessary to continue the enumeration if successful; NULL otherwise.<p> A path is represented as an array of literals, which are integers in {0, 1, 2}; 0 represents an else arc out of a node, 1 represents a then arc out of a node, and 2 stands for the absence of a node. The size of the array equals the number of variables in the manager at the time Cudd_zddFirstCube is called.<p> The paths that end in the empty terminal are not enumerated.
6991<p>
6992
6993<dd> <b>Side Effects</b> The first path is returned as a side effect.
6994<p>
6995
6996<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_zddForeachPath">Cudd_zddForeachPath</a>
6997<a href="cuddAllDet.html#Cudd_zddNextPath">Cudd_zddNextPath</a>
6998<a href="cuddAllDet.html#Cudd_GenFree">Cudd_GenFree</a>
6999<a href="cuddAllDet.html#Cudd_IsGenEmpty">Cudd_IsGenEmpty</a>
7000</code>
7001
7002<dt><pre>
7003 <i></i>
7004<a name="Cudd_zddForeachPath"><b>Cudd_zddForeachPath</b></a>(
7005   <b>manager</b>, <i></i>
7006   <b>f</b>, <i></i>
7007   <b>gen</b>, <i></i>
7008   <b>path</b> <i></i>
7009)
7010</pre>
7011<dd> Iterates over the paths of a ZDD f. <ul> <li> DdManager *manager; <li> DdNode *f; <li> DdGen *gen; <li> int *path; </ul> Cudd_zddForeachPath allocates and frees the generator. Therefore the application should not try to do that. Also, the path is freed at the end of Cudd_zddForeachPath and hence is not available outside of the loop.<p> CAUTION: It is assumed that dynamic reordering will not occur while there are open generators. It is the user's responsibility to make sure that dynamic reordering does not occur. As long as new nodes are not created during generation, and dynamic reordering is not called explicitly, dynamic reordering will not occur. Alternatively, it is sufficient to disable dynamic reordering. It is a mistake to dispose of a diagram on which generation is ongoing.
7012<p>
7013
7014<dd> <b>Side Effects</b> none
7015<p>
7016
7017<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_zddFirstPath">Cudd_zddFirstPath</a>
7018<a href="cuddAllDet.html#Cudd_zddNextPath">Cudd_zddNextPath</a>
7019<a href="cuddAllDet.html#Cudd_GenFree">Cudd_GenFree</a>
7020<a href="cuddAllDet.html#Cudd_IsGenEmpty">Cudd_IsGenEmpty</a>
7021<a href="cuddAllDet.html#Cudd_AutodynDisable">Cudd_AutodynDisable</a>
7022</code>
7023
7024<dt><pre>
7025DdNode * <i></i>
7026<a name="Cudd_zddIntersect"><b>Cudd_zddIntersect</b></a>(
7027  DdManager * <b>dd</b>, <i></i>
7028  DdNode * <b>P</b>, <i></i>
7029  DdNode * <b>Q</b> <i></i>
7030)
7031</pre>
7032<dd> Computes the intersection of two ZDDs. Returns a pointer to the result if successful; NULL otherwise.
7033<p>
7034
7035<dd> <b>Side Effects</b> None
7036<p>
7037
7038<dt><pre>
7039DdNode  * <i></i>
7040<a name="Cudd_zddIsop"><b>Cudd_zddIsop</b></a>(
7041  DdManager * <b>dd</b>, <i></i>
7042  DdNode * <b>L</b>, <i></i>
7043  DdNode * <b>U</b>, <i></i>
7044  DdNode ** <b>zdd_I</b> <i></i>
7045)
7046</pre>
7047<dd> Computes an irredundant sum of products (ISOP) in ZDD form from BDDs. The two BDDs L and U represent the lower bound and the upper bound, respectively, of the function. The ISOP uses two ZDD variables for each BDD variable: One for the positive literal, and one for the negative literal. These two variables should be adjacent in the ZDD order. The two ZDD variables corresponding to BDD variable <code>i</code> should have indices <code>2i</code> and <code>2i+1</code>. The result of this procedure depends on the variable order. If successful, Cudd_zddIsop returns the BDD for the function chosen from the interval. The ZDD representing the irredundant cover is returned as a side effect in zdd_I. In case of failure, NULL is returned.
7048<p>
7049
7050<dd> <b>Side Effects</b> zdd_I holds the pointer to the ZDD for the ISOP on successful return.
7051<p>
7052
7053<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_bddIsop">Cudd_bddIsop</a>
7054<a href="cuddAllDet.html#Cudd_zddVarsFromBddVars">Cudd_zddVarsFromBddVars</a>
7055</code>
7056
7057<dt><pre>
7058DdNode * <i></i>
7059<a name="Cudd_zddIte"><b>Cudd_zddIte</b></a>(
7060  DdManager * <b>dd</b>, <i></i>
7061  DdNode * <b>f</b>, <i></i>
7062  DdNode * <b>g</b>, <i></i>
7063  DdNode * <b>h</b> <i></i>
7064)
7065</pre>
7066<dd> Computes the ITE of three ZDDs. Returns a pointer to the result if successful; NULL otherwise.
7067<p>
7068
7069<dd> <b>Side Effects</b> None
7070<p>
7071
7072<dt><pre>
7073DdNode * <i></i>
7074<a name="Cudd_zddIthVar"><b>Cudd_zddIthVar</b></a>(
7075  DdManager * <b>dd</b>, <i></i>
7076  int  <b>i</b> <i></i>
7077)
7078</pre>
7079<dd> Retrieves the ZDD variable with index i if it already exists, or creates a new ZDD variable. Returns a pointer to the variable if successful; NULL otherwise.
7080<p>
7081
7082<dd> <b>Side Effects</b> None
7083<p>
7084
7085<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_bddIthVar">Cudd_bddIthVar</a>
7086<a href="cuddAllDet.html#Cudd_addIthVar">Cudd_addIthVar</a>
7087</code>
7088
7089<dt><pre>
7090int <i></i>
7091<a name="Cudd_zddNextPath"><b>Cudd_zddNextPath</b></a>(
7092  DdGen * <b>gen</b>, <i></i>
7093  int ** <b>path</b> <i></i>
7094)
7095</pre>
7096<dd> Generates the next path of a ZDD onset, using generator gen. Returns 0 if the enumeration is completed; 1 otherwise.
7097<p>
7098
7099<dd> <b>Side Effects</b> The path is returned as a side effect. The generator is modified.
7100<p>
7101
7102<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_zddForeachPath">Cudd_zddForeachPath</a>
7103<a href="cuddAllDet.html#Cudd_zddFirstPath">Cudd_zddFirstPath</a>
7104<a href="cuddAllDet.html#Cudd_GenFree">Cudd_GenFree</a>
7105<a href="cuddAllDet.html#Cudd_IsGenEmpty">Cudd_IsGenEmpty</a>
7106</code>
7107
7108<dt><pre>
7109DdNode * <i></i>
7110<a name="Cudd_zddPortFromBdd"><b>Cudd_zddPortFromBdd</b></a>(
7111  DdManager * <b>dd</b>, <i></i>
7112  DdNode * <b>B</b> <i></i>
7113)
7114</pre>
7115<dd> Converts a BDD into a ZDD. This function assumes that there is a one-to-one correspondence between the BDD variables and the ZDD variables, and that the variable order is the same for both types of variables. These conditions are established if the ZDD variables are created by one call to Cudd_zddVarsFromBddVars with multiplicity = 1. Returns a pointer to the resulting ZDD if successful; NULL otherwise.
7116<p>
7117
7118<dd> <b>Side Effects</b> None
7119<p>
7120
7121<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_zddVarsFromBddVars">Cudd_zddVarsFromBddVars</a>
7122</code>
7123
7124<dt><pre>
7125DdNode * <i></i>
7126<a name="Cudd_zddPortToBdd"><b>Cudd_zddPortToBdd</b></a>(
7127  DdManager * <b>dd</b>, <i></i>
7128  DdNode * <b>f</b> <i></i>
7129)
7130</pre>
7131<dd> Converts a ZDD into a BDD. Returns a pointer to the resulting ZDD if successful; NULL otherwise.
7132<p>
7133
7134<dd> <b>Side Effects</b> None
7135<p>
7136
7137<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_zddPortFromBdd">Cudd_zddPortFromBdd</a>
7138</code>
7139
7140<dt><pre>
7141int <i></i>
7142<a name="Cudd_zddPrintCover"><b>Cudd_zddPrintCover</b></a>(
7143  DdManager * <b>zdd</b>, <i></i>
7144  DdNode * <b>node</b> <i></i>
7145)
7146</pre>
7147<dd> Prints a sum of products from a ZDD representing a cover. Returns 1 if successful; 0 otherwise.
7148<p>
7149
7150<dd> <b>Side Effects</b> None
7151<p>
7152
7153<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_zddPrintMinterm">Cudd_zddPrintMinterm</a>
7154</code>
7155
7156<dt><pre>
7157int <i></i>
7158<a name="Cudd_zddPrintDebug"><b>Cudd_zddPrintDebug</b></a>(
7159  DdManager * <b>zdd</b>, <i></i>
7160  DdNode * <b>f</b>, <i></i>
7161  int  <b>n</b>, <i></i>
7162  int  <b>pr</b> <i></i>
7163)
7164</pre>
7165<dd> Prints to the standard output a DD and its statistics. The statistics include the number of nodes and the number of minterms. (The number of minterms is also the number of combinations in the set.) The statistics are printed if pr &gt; 0. Specifically: <ul> <li> pr = 0 : prints nothing <li> pr = 1 : prints counts of nodes and minterms <li> pr = 2 : prints counts + disjoint sum of products <li> pr = 3 : prints counts + list of nodes <li> pr &gt; 3 : prints counts + disjoint sum of products + list of nodes </ul> Returns 1 if successful; 0 otherwise.
7166<p>
7167
7168<dd> <b>Side Effects</b> None
7169<p>
7170
7171<dt><pre>
7172int <i></i>
7173<a name="Cudd_zddPrintMinterm"><b>Cudd_zddPrintMinterm</b></a>(
7174  DdManager * <b>zdd</b>, <i></i>
7175  DdNode * <b>node</b> <i></i>
7176)
7177</pre>
7178<dd> Prints a disjoint sum of product form for a ZDD. Returns 1 if successful; 0 otherwise.
7179<p>
7180
7181<dd> <b>Side Effects</b> None
7182<p>
7183
7184<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_zddPrintDebug">Cudd_zddPrintDebug</a>
7185<a href="cuddAllDet.html#Cudd_zddPrintCover">Cudd_zddPrintCover</a>
7186</code>
7187
7188<dt><pre>
7189void <i></i>
7190<a name="Cudd_zddPrintSubtable"><b>Cudd_zddPrintSubtable</b></a>(
7191  DdManager * <b>table</b> <i></i>
7192)
7193</pre>
7194<dd> Prints the ZDD table for debugging purposes.
7195<p>
7196
7197<dd> <b>Side Effects</b> None
7198<p>
7199
7200<dt><pre>
7201DdNode  * <i></i>
7202<a name="Cudd_zddProduct"><b>Cudd_zddProduct</b></a>(
7203  DdManager * <b>dd</b>, <i></i>
7204  DdNode * <b>f</b>, <i></i>
7205  DdNode * <b>g</b> <i></i>
7206)
7207</pre>
7208<dd> Computes the product of two covers represented by ZDDs. The result is also a ZDD. Returns a pointer to the result if successful; NULL otherwise. The covers on which Cudd_zddProduct operates use two ZDD variables for each function variable (one ZDD variable for each literal of the variable). Those two ZDD variables should be adjacent in the order.
7209<p>
7210
7211<dd> <b>Side Effects</b> None
7212<p>
7213
7214<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_zddUnateProduct">Cudd_zddUnateProduct</a>
7215</code>
7216
7217<dt><pre>
7218long <i></i>
7219<a name="Cudd_zddReadNodeCount"><b>Cudd_zddReadNodeCount</b></a>(
7220  DdManager * <b>dd</b> <i></i>
7221)
7222</pre>
7223<dd> Reports the number of nodes in ZDDs. This number always includes the two constants 1 and 0.
7224<p>
7225
7226<dd> <b>Side Effects</b> None
7227<p>
7228
7229<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_ReadPeakNodeCount">Cudd_ReadPeakNodeCount</a>
7230<a href="cuddAllDet.html#Cudd_ReadNodeCount">Cudd_ReadNodeCount</a>
7231</code>
7232
7233<dt><pre>
7234void <i></i>
7235<a name="Cudd_zddRealignDisable"><b>Cudd_zddRealignDisable</b></a>(
7236  DdManager * <b>unique</b> <i></i>
7237)
7238</pre>
7239<dd> Disables realignment of ZDD order to BDD order.
7240<p>
7241
7242<dd> <b>Side Effects</b> None
7243<p>
7244
7245<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_zddRealignEnable">Cudd_zddRealignEnable</a>
7246<a href="cuddAllDet.html#Cudd_zddRealignmentEnabled">Cudd_zddRealignmentEnabled</a>
7247<a href="cuddAllDet.html#Cudd_bddRealignEnable">Cudd_bddRealignEnable</a>
7248<a href="cuddAllDet.html#Cudd_bddRealignmentEnabled">Cudd_bddRealignmentEnabled</a>
7249</code>
7250
7251<dt><pre>
7252void <i></i>
7253<a name="Cudd_zddRealignEnable"><b>Cudd_zddRealignEnable</b></a>(
7254  DdManager * <b>unique</b> <i></i>
7255)
7256</pre>
7257<dd> 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.
7258<p>
7259
7260<dd> <b>Side Effects</b> None
7261<p>
7262
7263<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_ReduceHeap">Cudd_ReduceHeap</a>
7264<a href="cuddAllDet.html#Cudd_zddRealignDisable">Cudd_zddRealignDisable</a>
7265<a href="cuddAllDet.html#Cudd_zddRealignmentEnabled">Cudd_zddRealignmentEnabled</a>
7266<a href="cuddAllDet.html#Cudd_bddRealignDisable">Cudd_bddRealignDisable</a>
7267<a href="cuddAllDet.html#Cudd_bddRealignmentEnabled">Cudd_bddRealignmentEnabled</a>
7268</code>
7269
7270<dt><pre>
7271int <i></i>
7272<a name="Cudd_zddRealignmentEnabled"><b>Cudd_zddRealignmentEnabled</b></a>(
7273  DdManager * <b>unique</b> <i></i>
7274)
7275</pre>
7276<dd> Returns 1 if the realignment of ZDD order to BDD order is enabled; 0 otherwise.
7277<p>
7278
7279<dd> <b>Side Effects</b> None
7280<p>
7281
7282<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_zddRealignEnable">Cudd_zddRealignEnable</a>
7283<a href="cuddAllDet.html#Cudd_zddRealignDisable">Cudd_zddRealignDisable</a>
7284<a href="cuddAllDet.html#Cudd_bddRealignEnable">Cudd_bddRealignEnable</a>
7285<a href="cuddAllDet.html#Cudd_bddRealignDisable">Cudd_bddRealignDisable</a>
7286</code>
7287
7288<dt><pre>
7289int <i></i>
7290<a name="Cudd_zddReduceHeap"><b>Cudd_zddReduceHeap</b></a>(
7291  DdManager * <b>table</b>, <i>DD manager</i>
7292  Cudd_ReorderingType  <b>heuristic</b>, <i>method used for reordering</i>
7293  int  <b>minsize</b> <i>bound below which no reordering occurs</i>
7294)
7295</pre>
7296<dd> Main dynamic reordering routine for ZDDs. Calls one of the possible reordering procedures: <ul> <li>Swapping <li>Sifting <li>Symmetric Sifting </ul> For sifting and symmetric sifting it is possible to request reordering to convergence.<p> The core of all methods is the reordering procedure cuddZddSwapInPlace() which swaps two adjacent variables. Returns 1 in case of success; 0 otherwise. In the case of symmetric sifting (with and without convergence) returns 1 plus the number of symmetric variables, in case of success.
7297<p>
7298
7299<dd> <b>Side Effects</b> Changes the variable order for all ZDDs and clears the cache.
7300<p>
7301
7302<dt><pre>
7303int <i></i>
7304<a name="Cudd_zddShuffleHeap"><b>Cudd_zddShuffleHeap</b></a>(
7305  DdManager * <b>table</b>, <i>DD manager</i>
7306  int * <b>permutation</b> <i>required variable permutation</i>
7307)
7308</pre>
7309<dd> Reorders ZDD variables according to given permutation. The i-th entry of the permutation array contains the index of the variable that should be brought to the i-th level. The size of the array should be equal or greater to the number of variables currently in use. Returns 1 in case of success; 0 otherwise.
7310<p>
7311
7312<dd> <b>Side Effects</b> Changes the ZDD variable order for all diagrams and clears the cache.
7313<p>
7314
7315<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_zddReduceHeap">Cudd_zddReduceHeap</a>
7316</code>
7317
7318<dt><pre>
7319DdNode * <i></i>
7320<a name="Cudd_zddSubset0"><b>Cudd_zddSubset0</b></a>(
7321  DdManager * <b>dd</b>, <i></i>
7322  DdNode * <b>P</b>, <i></i>
7323  int  <b>var</b> <i></i>
7324)
7325</pre>
7326<dd> Computes the negative cofactor of a ZDD w.r.t. a variable. In terms of combinations, the result is the set of all combinations in which the variable is negated. Returns a pointer to the result if successful; NULL otherwise.
7327<p>
7328
7329<dd> <b>Side Effects</b> None
7330<p>
7331
7332<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_zddSubset1">Cudd_zddSubset1</a>
7333</code>
7334
7335<dt><pre>
7336DdNode * <i></i>
7337<a name="Cudd_zddSubset1"><b>Cudd_zddSubset1</b></a>(
7338  DdManager * <b>dd</b>, <i></i>
7339  DdNode * <b>P</b>, <i></i>
7340  int  <b>var</b> <i></i>
7341)
7342</pre>
7343<dd> Computes the positive cofactor of a ZDD w.r.t. a variable. In terms of combinations, the result is the set of all combinations in which the variable is asserted. Returns a pointer to the result if successful; NULL otherwise.
7344<p>
7345
7346<dd> <b>Side Effects</b> None
7347<p>
7348
7349<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_zddSubset0">Cudd_zddSubset0</a>
7350</code>
7351
7352<dt><pre>
7353void <i></i>
7354<a name="Cudd_zddSymmProfile"><b>Cudd_zddSymmProfile</b></a>(
7355  DdManager * <b>table</b>, <i></i>
7356  int  <b>lower</b>, <i></i>
7357  int  <b>upper</b> <i></i>
7358)
7359</pre>
7360<dd> Prints statistics on symmetric ZDD variables.
7361<p>
7362
7363<dd> <b>Side Effects</b> None
7364<p>
7365
7366<dt><pre>
7367DdNode  * <i></i>
7368<a name="Cudd_zddUnateProduct"><b>Cudd_zddUnateProduct</b></a>(
7369  DdManager * <b>dd</b>, <i></i>
7370  DdNode * <b>f</b>, <i></i>
7371  DdNode * <b>g</b> <i></i>
7372)
7373</pre>
7374<dd> Computes the product of two unate covers represented as ZDDs. Unate covers use one ZDD variable for each BDD variable. Returns a pointer to the result if successful; NULL otherwise.
7375<p>
7376
7377<dd> <b>Side Effects</b> None
7378<p>
7379
7380<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_zddProduct">Cudd_zddProduct</a>
7381</code>
7382
7383<dt><pre>
7384DdNode * <i></i>
7385<a name="Cudd_zddUnion"><b>Cudd_zddUnion</b></a>(
7386  DdManager * <b>dd</b>, <i></i>
7387  DdNode * <b>P</b>, <i></i>
7388  DdNode * <b>Q</b> <i></i>
7389)
7390</pre>
7391<dd> Computes the union of two ZDDs. Returns a pointer to the result if successful; NULL otherwise.
7392<p>
7393
7394<dd> <b>Side Effects</b> None
7395<p>
7396
7397<dt><pre>
7398int <i></i>
7399<a name="Cudd_zddVarsFromBddVars"><b>Cudd_zddVarsFromBddVars</b></a>(
7400  DdManager * <b>dd</b>, <i>DD manager</i>
7401  int  <b>multiplicity</b> <i>how many ZDD variables are created for each BDD variable</i>
7402)
7403</pre>
7404<dd> Creates one or more ZDD variables for each BDD variable. 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. Returns 1 if successful; 0 otherwise.
7405<p>
7406
7407<dd> <b>Side Effects</b> None
7408<p>
7409
7410<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_bddNewVar">Cudd_bddNewVar</a>
7411<a href="cuddAllDet.html#Cudd_bddIthVar">Cudd_bddIthVar</a>
7412<a href="cuddAllDet.html#Cudd_bddNewVarAtLevel">Cudd_bddNewVarAtLevel</a>
7413</code>
7414
7415<dt><pre>
7416DdNode  * <i></i>
7417<a name="Cudd_zddWeakDivF"><b>Cudd_zddWeakDivF</b></a>(
7418  DdManager * <b>dd</b>, <i></i>
7419  DdNode * <b>f</b>, <i></i>
7420  DdNode * <b>g</b> <i></i>
7421)
7422</pre>
7423<dd> Modified version of Cudd_zddWeakDiv. This function may disappear in future releases.
7424<p>
7425
7426<dd> <b>Side Effects</b> None
7427<p>
7428
7429<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_zddWeakDiv">Cudd_zddWeakDiv</a>
7430</code>
7431
7432<dt><pre>
7433DdNode  * <i></i>
7434<a name="Cudd_zddWeakDiv"><b>Cudd_zddWeakDiv</b></a>(
7435  DdManager * <b>dd</b>, <i></i>
7436  DdNode * <b>f</b>, <i></i>
7437  DdNode * <b>g</b> <i></i>
7438)
7439</pre>
7440<dd> Applies weak division to two ZDDs representing two covers. Returns a pointer to the ZDD representing the result if successful; NULL otherwise. The result of weak division depends on the variable order. The covers on which Cudd_zddWeakDiv operates use two ZDD variables for each function variable (one ZDD variable for each literal of the variable). Those two ZDD variables should be adjacent in the order.
7441<p>
7442
7443<dd> <b>Side Effects</b> None
7444<p>
7445
7446<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_zddDivide">Cudd_zddDivide</a>
7447</code>
7448
7449
7450</dl>
7451
7452<hr>
7453
7454Generated automatically by <code>extdoc</code> on 20050517
7455
7456</body></html>
Note: See TracBrowser for help on using the repository browser.