source: vis_dev/glu-2.3/src/cuBdd/doc/cuddAllDet.html @ 99

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

library glu 2.3
File size: 381.6 KB
Line 
1<html>
2<head><title>The cudd package (Internal) </title></head>
3<body>
4
5<h1>The cudd package (Internal) </h1>
6<h2>Internal data structures of the CUDD 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">
19
20</a>
21
22<hr>
23<!-- Function Prototypes and description -->
24
25<dl>
26<a name="prototypes"></a>
27<dt><pre>
28int <i></i>
29<a name="Cudd_AddHook"><b>Cudd_AddHook</b></a>(
30  DdManager * <b>dd</b>, <i></i>
31  DD_HFP  <b>f</b>, <i></i>
32  Cudd_HookType  <b>where</b> <i></i>
33)
34</pre>
35<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.
36<p>
37
38<dd> <b>Side Effects</b> None
39<p>
40
41<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_RemoveHook">Cudd_RemoveHook</a>
42</code>
43
44<dt><pre>
45DdApaDigit <i></i>
46<a name="Cudd_ApaAdd"><b>Cudd_ApaAdd</b></a>(
47  int  <b>digits</b>, <i></i>
48  DdApaNumber  <b>a</b>, <i></i>
49  DdApaNumber  <b>b</b>, <i></i>
50  DdApaNumber  <b>sum</b> <i></i>
51)
52</pre>
53<dd> Adds two arbitrary precision integers. Returns the carry out of the most significant digit.
54<p>
55
56<dd> <b>Side Effects</b> The result of the sum is stored in parameter <code>sum</code>.
57<p>
58
59<dt><pre>
60int <i></i>
61<a name="Cudd_ApaCompareRatios"><b>Cudd_ApaCompareRatios</b></a>(
62  int  <b>digitsFirst</b>, <i></i>
63  DdApaNumber  <b>firstNum</b>, <i></i>
64  unsigned int  <b>firstDen</b>, <i></i>
65  int  <b>digitsSecond</b>, <i></i>
66  DdApaNumber  <b>secondNum</b>, <i></i>
67  unsigned int  <b>secondDen</b> <i></i>
68)
69</pre>
70<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.
71<p>
72
73<dd> <b>Side Effects</b> None
74<p>
75
76<dt><pre>
77int <i></i>
78<a name="Cudd_ApaCompare"><b>Cudd_ApaCompare</b></a>(
79  int  <b>digitsFirst</b>, <i></i>
80  DdApaNumber  <b>first</b>, <i></i>
81  int  <b>digitsSecond</b>, <i></i>
82  DdApaNumber  <b>second</b> <i></i>
83)
84</pre>
85<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.
86<p>
87
88<dd> <b>Side Effects</b> None
89<p>
90
91<dt><pre>
92void <i></i>
93<a name="Cudd_ApaCopy"><b>Cudd_ApaCopy</b></a>(
94  int  <b>digits</b>, <i></i>
95  DdApaNumber  <b>source</b>, <i></i>
96  DdApaNumber  <b>dest</b> <i></i>
97)
98</pre>
99<dd> Makes a copy of an arbitrary precision integer.
100<p>
101
102<dd> <b>Side Effects</b> Changes parameter <code>dest</code>.
103<p>
104
105<dt><pre>
106DdApaNumber <i></i>
107<a name="Cudd_ApaCountMinterm"><b>Cudd_ApaCountMinterm</b></a>(
108  DdManager * <b>manager</b>, <i></i>
109  DdNode * <b>node</b>, <i></i>
110  int  <b>nvars</b>, <i></i>
111  int * <b>digits</b> <i></i>
112)
113</pre>
114<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.
115<p>
116
117<dd> <b>Side Effects</b> The number of digits of the result is returned in parameter <code>digits</code>.
118<p>
119
120<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_CountMinterm">Cudd_CountMinterm</a>
121</code>
122
123<dt><pre>
124unsigned int <i></i>
125<a name="Cudd_ApaIntDivision"><b>Cudd_ApaIntDivision</b></a>(
126  int  <b>digits</b>, <i></i>
127  DdApaNumber  <b>dividend</b>, <i></i>
128  unsigned int  <b>divisor</b>, <i></i>
129  DdApaNumber  <b>quotient</b> <i></i>
130)
131</pre>
132<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.
133<p>
134
135<dd> <b>Side Effects</b> The quotient is returned in parameter <code>quotient</code>.
136<p>
137
138<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_ApaShortDivision">Cudd_ApaShortDivision</a>
139</code>
140
141<dt><pre>
142int <i></i>
143<a name="Cudd_ApaNumberOfDigits"><b>Cudd_ApaNumberOfDigits</b></a>(
144  int  <b>binaryDigits</b> <i></i>
145)
146</pre>
147<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.
148<p>
149
150<dd> <b>Side Effects</b> None
151<p>
152
153<dt><pre>
154void <i></i>
155<a name="Cudd_ApaPowerOfTwo"><b>Cudd_ApaPowerOfTwo</b></a>(
156  int  <b>digits</b>, <i></i>
157  DdApaNumber  <b>number</b>, <i></i>
158  int  <b>power</b> <i></i>
159)
160</pre>
161<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.
162<p>
163
164<dd> <b>Side Effects</b> The result is returned in parameter <code>number</code>.
165<p>
166
167<dt><pre>
168int <i></i>
169<a name="Cudd_ApaPrintDecimal"><b>Cudd_ApaPrintDecimal</b></a>(
170  FILE * <b>fp</b>, <i></i>
171  int  <b>digits</b>, <i></i>
172  DdApaNumber  <b>number</b> <i></i>
173)
174</pre>
175<dd> Prints an arbitrary precision integer in decimal format. Returns 1 if successful; 0 otherwise.
176<p>
177
178<dd> <b>Side Effects</b> None
179<p>
180
181<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_ApaPrintHex">Cudd_ApaPrintHex</a>
182<a href="cuddAllDet.html#Cudd_ApaPrintExponential">Cudd_ApaPrintExponential</a>
183</code>
184
185<dt><pre>
186int <i></i>
187<a name="Cudd_ApaPrintDensity"><b>Cudd_ApaPrintDensity</b></a>(
188  FILE * <b>fp</b>, <i></i>
189  DdManager * <b>dd</b>, <i></i>
190  DdNode * <b>node</b>, <i></i>
191  int  <b>nvars</b> <i></i>
192)
193</pre>
194<dd> Prints the density of a BDD or ADD using arbitrary precision arithmetic. Returns 1 if successful; 0 otherwise.
195<p>
196
197<dd> <b>Side Effects</b> None
198<p>
199
200<dt><pre>
201int <i></i>
202<a name="Cudd_ApaPrintExponential"><b>Cudd_ApaPrintExponential</b></a>(
203  FILE * <b>fp</b>, <i></i>
204  int  <b>digits</b>, <i></i>
205  DdApaNumber  <b>number</b>, <i></i>
206  int  <b>precision</b> <i></i>
207)
208</pre>
209<dd> Prints an arbitrary precision integer in exponential format. Returns 1 if successful; 0 otherwise.
210<p>
211
212<dd> <b>Side Effects</b> None
213<p>
214
215<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_ApaPrintHex">Cudd_ApaPrintHex</a>
216<a href="cuddAllDet.html#Cudd_ApaPrintDecimal">Cudd_ApaPrintDecimal</a>
217</code>
218
219<dt><pre>
220int <i></i>
221<a name="Cudd_ApaPrintHex"><b>Cudd_ApaPrintHex</b></a>(
222  FILE * <b>fp</b>, <i></i>
223  int  <b>digits</b>, <i></i>
224  DdApaNumber  <b>number</b> <i></i>
225)
226</pre>
227<dd> Prints an arbitrary precision integer in hexadecimal format. Returns 1 if successful; 0 otherwise.
228<p>
229
230<dd> <b>Side Effects</b> None
231<p>
232
233<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_ApaPrintDecimal">Cudd_ApaPrintDecimal</a>
234<a href="cuddAllDet.html#Cudd_ApaPrintExponential">Cudd_ApaPrintExponential</a>
235</code>
236
237<dt><pre>
238int <i></i>
239<a name="Cudd_ApaPrintMintermExp"><b>Cudd_ApaPrintMintermExp</b></a>(
240  FILE * <b>fp</b>, <i></i>
241  DdManager * <b>dd</b>, <i></i>
242  DdNode * <b>node</b>, <i></i>
243  int  <b>nvars</b>, <i></i>
244  int  <b>precision</b> <i></i>
245)
246</pre>
247<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.
248<p>
249
250<dd> <b>Side Effects</b> None
251<p>
252
253<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_ApaPrintMinterm">Cudd_ApaPrintMinterm</a>
254</code>
255
256<dt><pre>
257int <i></i>
258<a name="Cudd_ApaPrintMinterm"><b>Cudd_ApaPrintMinterm</b></a>(
259  FILE * <b>fp</b>, <i></i>
260  DdManager * <b>dd</b>, <i></i>
261  DdNode * <b>node</b>, <i></i>
262  int  <b>nvars</b> <i></i>
263)
264</pre>
265<dd> Prints the number of minterms of a BDD or ADD using arbitrary precision arithmetic. Returns 1 if successful; 0 otherwise.
266<p>
267
268<dd> <b>Side Effects</b> None
269<p>
270
271<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_ApaPrintMintermExp">Cudd_ApaPrintMintermExp</a>
272</code>
273
274<dt><pre>
275void <i></i>
276<a name="Cudd_ApaSetToLiteral"><b>Cudd_ApaSetToLiteral</b></a>(
277  int  <b>digits</b>, <i></i>
278  DdApaNumber  <b>number</b>, <i></i>
279  DdApaDigit  <b>literal</b> <i></i>
280)
281</pre>
282<dd> Sets an arbitrary precision integer to a one-digit literal.
283<p>
284
285<dd> <b>Side Effects</b> The result is returned in parameter <code>number</code>.
286<p>
287
288<dt><pre>
289void <i></i>
290<a name="Cudd_ApaShiftRight"><b>Cudd_ApaShiftRight</b></a>(
291  int  <b>digits</b>, <i></i>
292  DdApaDigit  <b>in</b>, <i></i>
293  DdApaNumber  <b>a</b>, <i></i>
294  DdApaNumber  <b>b</b> <i></i>
295)
296</pre>
297<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>.
298<p>
299
300<dd> <b>Side Effects</b> The result is returned in parameter <code>b</code>.
301<p>
302
303<dt><pre>
304DdApaDigit <i></i>
305<a name="Cudd_ApaShortDivision"><b>Cudd_ApaShortDivision</b></a>(
306  int  <b>digits</b>, <i></i>
307  DdApaNumber  <b>dividend</b>, <i></i>
308  DdApaDigit  <b>divisor</b>, <i></i>
309  DdApaNumber  <b>quotient</b> <i></i>
310)
311</pre>
312<dd> Divides an arbitrary precision integer by a digit.
313<p>
314
315<dd> <b>Side Effects</b> The quotient is returned in parameter <code>quotient</code>.
316<p>
317
318<dt><pre>
319DdApaDigit <i></i>
320<a name="Cudd_ApaSubtract"><b>Cudd_ApaSubtract</b></a>(
321  int  <b>digits</b>, <i></i>
322  DdApaNumber  <b>a</b>, <i></i>
323  DdApaNumber  <b>b</b>, <i></i>
324  DdApaNumber  <b>diff</b> <i></i>
325)
326</pre>
327<dd> Subtracts two arbitrary precision integers. Returns the borrow out of the most significant digit.
328<p>
329
330<dd> <b>Side Effects</b> The result of the subtraction is stored in parameter <code>diff</code>.
331<p>
332
333<dt><pre>
334void <i></i>
335<a name="Cudd_AutodynDisableZdd"><b>Cudd_AutodynDisableZdd</b></a>(
336  DdManager * <b>unique</b> <i></i>
337)
338</pre>
339<dd> Disables automatic dynamic reordering of ZDDs.
340<p>
341
342<dd> <b>Side Effects</b> None
343<p>
344
345<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_AutodynEnableZdd">Cudd_AutodynEnableZdd</a>
346<a href="cuddAllDet.html#Cudd_ReorderingStatusZdd">Cudd_ReorderingStatusZdd</a>
347<a href="cuddAllDet.html#Cudd_AutodynDisable">Cudd_AutodynDisable</a>
348</code>
349
350<dt><pre>
351void <i></i>
352<a name="Cudd_AutodynDisable"><b>Cudd_AutodynDisable</b></a>(
353  DdManager * <b>unique</b> <i></i>
354)
355</pre>
356<dd> Disables automatic dynamic reordering.
357<p>
358
359<dd> <b>Side Effects</b> None
360<p>
361
362<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_AutodynEnable">Cudd_AutodynEnable</a>
363<a href="cuddAllDet.html#Cudd_ReorderingStatus">Cudd_ReorderingStatus</a>
364<a href="cuddAllDet.html#Cudd_AutodynDisableZdd">Cudd_AutodynDisableZdd</a>
365</code>
366
367<dt><pre>
368void <i></i>
369<a name="Cudd_AutodynEnableZdd"><b>Cudd_AutodynEnableZdd</b></a>(
370  DdManager * <b>unique</b>, <i></i>
371  Cudd_ReorderingType  <b>method</b> <i></i>
372)
373</pre>
374<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.
375<p>
376
377<dd> <b>Side Effects</b> None
378<p>
379
380<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_AutodynDisableZdd">Cudd_AutodynDisableZdd</a>
381<a href="cuddAllDet.html#Cudd_ReorderingStatusZdd">Cudd_ReorderingStatusZdd</a>
382<a href="cuddAllDet.html#Cudd_AutodynEnable">Cudd_AutodynEnable</a>
383</code>
384
385<dt><pre>
386void <i></i>
387<a name="Cudd_AutodynEnable"><b>Cudd_AutodynEnable</b></a>(
388  DdManager * <b>unique</b>, <i></i>
389  Cudd_ReorderingType  <b>method</b> <i></i>
390)
391</pre>
392<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.
393<p>
394
395<dd> <b>Side Effects</b> None
396<p>
397
398<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_AutodynDisable">Cudd_AutodynDisable</a>
399<a href="cuddAllDet.html#Cudd_ReorderingStatus">Cudd_ReorderingStatus</a>
400<a href="cuddAllDet.html#Cudd_AutodynEnableZdd">Cudd_AutodynEnableZdd</a>
401</code>
402
403<dt><pre>
404double <i></i>
405<a name="Cudd_AverageDistance"><b>Cudd_AverageDistance</b></a>(
406  DdManager * <b>dd</b> <i></i>
407)
408</pre>
409<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.
410<p>
411
412<dd> <b>Side Effects</b> None
413<p>
414
415<dt><pre>
416DdNode * <i></i>
417<a name="Cudd_BddToAdd"><b>Cudd_BddToAdd</b></a>(
418  DdManager * <b>dd</b>, <i></i>
419  DdNode * <b>B</b> <i></i>
420)
421</pre>
422<dd> Converts a BDD to a 0-1 ADD. Returns a pointer to the resulting ADD if successful; NULL otherwise.
423<p>
424
425<dd> <b>Side Effects</b> None
426<p>
427
428<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_addBddPattern">Cudd_addBddPattern</a>
429<a href="cuddAllDet.html#Cudd_addBddThreshold">Cudd_addBddThreshold</a>
430<a href="cuddAllDet.html#Cudd_addBddInterval">Cudd_addBddInterval</a>
431<a href="cuddAllDet.html#Cudd_addBddStrictThreshold">Cudd_addBddStrictThreshold</a>
432</code>
433
434<dt><pre>
435int <i></i>
436<a name="Cudd_BddToCubeArray"><b>Cudd_BddToCubeArray</b></a>(
437  DdManager * <b>dd</b>, <i></i>
438  DdNode * <b>cube</b>, <i></i>
439  int * <b>array</b> <i></i>
440)
441</pre>
442<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.
443<p>
444
445<dd> <b>Side Effects</b> The result is in the array passed by reference.
446<p>
447
448<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_CubeArrayToBdd">Cudd_CubeArrayToBdd</a>
449</code>
450
451<dt><pre>
452DdNode * <i></i>
453<a name="Cudd_BiasedOverApprox"><b>Cudd_BiasedOverApprox</b></a>(
454  DdManager * <b>dd</b>, <i>manager</i>
455  DdNode * <b>f</b>, <i>function to be superset</i>
456  DdNode * <b>b</b>, <i>bias function</i>
457  int  <b>numVars</b>, <i>number of variables in the support of f</i>
458  int  <b>threshold</b>, <i>when to stop approximation</i>
459  double  <b>quality1</b>, <i>minimum improvement for accepted changes when b=1</i>
460  double  <b>quality0</b> <i>minimum improvement for accepted changes when b=0</i>
461)
462</pre>
463<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.
464<p>
465
466<dd> <b>Side Effects</b> None
467<p>
468
469<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_SupersetHeavyBranch">Cudd_SupersetHeavyBranch</a>
470<a href="cuddAllDet.html#Cudd_SupersetShortPaths">Cudd_SupersetShortPaths</a>
471<a href="cuddAllDet.html#Cudd_RemapOverApprox">Cudd_RemapOverApprox</a>
472<a href="cuddAllDet.html#Cudd_BiasedUnderApprox">Cudd_BiasedUnderApprox</a>
473<a href="cuddAllDet.html#Cudd_ReadSize">Cudd_ReadSize</a>
474</code>
475
476<dt><pre>
477DdNode * <i></i>
478<a name="Cudd_BiasedUnderApprox"><b>Cudd_BiasedUnderApprox</b></a>(
479  DdManager * <b>dd</b>, <i>manager</i>
480  DdNode * <b>f</b>, <i>function to be subset</i>
481  DdNode * <b>b</b>, <i>bias function</i>
482  int  <b>numVars</b>, <i>number of variables in the support of f</i>
483  int  <b>threshold</b>, <i>when to stop approximation</i>
484  double  <b>quality1</b>, <i>minimum improvement for accepted changes when b=1</i>
485  double  <b>quality0</b> <i>minimum improvement for accepted changes when b=0</i>
486)
487</pre>
488<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.
489<p>
490
491<dd> <b>Side Effects</b> None
492<p>
493
494<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_SubsetShortPaths">Cudd_SubsetShortPaths</a>
495<a href="cuddAllDet.html#Cudd_SubsetHeavyBranch">Cudd_SubsetHeavyBranch</a>
496<a href="cuddAllDet.html#Cudd_UnderApprox">Cudd_UnderApprox</a>
497<a href="cuddAllDet.html#Cudd_RemapUnderApprox">Cudd_RemapUnderApprox</a>
498<a href="cuddAllDet.html#Cudd_ReadSize">Cudd_ReadSize</a>
499</code>
500
501<dt><pre>
502DdNode * <i></i>
503<a name="Cudd_CProjection"><b>Cudd_CProjection</b></a>(
504  DdManager * <b>dd</b>, <i></i>
505  DdNode * <b>R</b>, <i></i>
506  DdNode * <b>Y</b> <i></i>
507)
508</pre>
509<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.
510<p>
511
512<dd> <b>Side Effects</b> None
513<p>
514
515<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_PrioritySelect">Cudd_PrioritySelect</a>
516</code>
517
518<dt><pre>
519int <i></i>
520<a name="Cudd_CheckKeys"><b>Cudd_CheckKeys</b></a>(
521  DdManager * <b>table</b> <i></i>
522)
523</pre>
524<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.
525<p>
526
527<dd> <b>Side Effects</b> None
528<p>
529
530<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_DebugCheck">Cudd_DebugCheck</a>
531</code>
532
533<dt><pre>
534int <i></i>
535<a name="Cudd_CheckZeroRef"><b>Cudd_CheckZeroRef</b></a>(
536  DdManager * <b>manager</b> <i></i>
537)
538</pre>
539<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.)
540<p>
541
542<dd> <b>Side Effects</b> None
543<p>
544
545<dt><pre>
546int <i></i>
547<a name="Cudd_ClassifySupport"><b>Cudd_ClassifySupport</b></a>(
548  DdManager * <b>dd</b>, <i>manager</i>
549  DdNode * <b>f</b>, <i>first DD</i>
550  DdNode * <b>g</b>, <i>second DD</i>
551  DdNode ** <b>common</b>, <i>cube of shared variables</i>
552  DdNode ** <b>onlyF</b>, <i>cube of variables only in f</i>
553  DdNode ** <b>onlyG</b> <i>cube of variables only in g</i>
554)
555</pre>
556<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.
557<p>
558
559<dd> <b>Side Effects</b> The cubes of the three classes of variables are returned as side effects.
560<p>
561
562<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_Support">Cudd_Support</a>
563<a href="cuddAllDet.html#Cudd_VectorSupport">Cudd_VectorSupport</a>
564</code>
565
566<dt><pre>
567void <i></i>
568<a name="Cudd_ClearErrorCode"><b>Cudd_ClearErrorCode</b></a>(
569  DdManager * <b>dd</b> <i></i>
570)
571</pre>
572<dd> Clear the error code of a manager.
573<p>
574
575<dd> <b>Side Effects</b> None
576<p>
577
578<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_ReadErrorCode">Cudd_ReadErrorCode</a>
579</code>
580
581<dt><pre>
582double * <i></i>
583<a name="Cudd_CofMinterm"><b>Cudd_CofMinterm</b></a>(
584  DdManager * <b>dd</b>, <i></i>
585  DdNode * <b>node</b> <i></i>
586)
587</pre>
588<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.
589<p>
590
591<dd> <b>Side Effects</b> None
592<p>
593
594<dt><pre>
595DdNode * <i></i>
596<a name="Cudd_Cofactor"><b>Cudd_Cofactor</b></a>(
597  DdManager * <b>dd</b>, <i></i>
598  DdNode * <b>f</b>, <i></i>
599  DdNode * <b>g</b> <i></i>
600)
601</pre>
602<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.
603<p>
604
605<dd> <b>Side Effects</b> None
606<p>
607
608<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_bddConstrain">Cudd_bddConstrain</a>
609<a href="cuddAllDet.html#Cudd_bddRestrict">Cudd_bddRestrict</a>
610</code>
611
612<dt><pre>
613 <i></i>
614<a name="Cudd_Complement"><b>Cudd_Complement</b></a>(
615   <b>node</b> <i></i>
616)
617</pre>
618<dd> Returns the complemented version of a pointer.
619<p>
620
621<dd> <b>Side Effects</b> none
622<p>
623
624<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_Regular">Cudd_Regular</a>
625<a href="cuddAllDet.html#Cudd_IsComplement">Cudd_IsComplement</a>
626</code>
627
628<dt><pre>
629int <i></i>
630<a name="Cudd_CountLeaves"><b>Cudd_CountLeaves</b></a>(
631  DdNode * <b>node</b> <i></i>
632)
633</pre>
634<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.
635<p>
636
637<dd> <b>Side Effects</b> None
638<p>
639
640<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_PrintDebug">Cudd_PrintDebug</a>
641</code>
642
643<dt><pre>
644double <i></i>
645<a name="Cudd_CountMinterm"><b>Cudd_CountMinterm</b></a>(
646  DdManager * <b>manager</b>, <i></i>
647  DdNode * <b>node</b>, <i></i>
648  int  <b>nvars</b> <i></i>
649)
650</pre>
651<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.
652<p>
653
654<dd> <b>Side Effects</b> None
655<p>
656
657<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_PrintDebug">Cudd_PrintDebug</a>
658<a href="cuddAllDet.html#Cudd_CountPath">Cudd_CountPath</a>
659</code>
660
661<dt><pre>
662double <i></i>
663<a name="Cudd_CountPathsToNonZero"><b>Cudd_CountPathsToNonZero</b></a>(
664  DdNode * <b>node</b> <i></i>
665)
666</pre>
667<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.
668<p>
669
670<dd> <b>Side Effects</b> None
671<p>
672
673<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_CountMinterm">Cudd_CountMinterm</a>
674<a href="cuddAllDet.html#Cudd_CountPath">Cudd_CountPath</a>
675</code>
676
677<dt><pre>
678double <i></i>
679<a name="Cudd_CountPath"><b>Cudd_CountPath</b></a>(
680  DdNode * <b>node</b> <i></i>
681)
682</pre>
683<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.
684<p>
685
686<dd> <b>Side Effects</b> None
687<p>
688
689<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_CountMinterm">Cudd_CountMinterm</a>
690</code>
691
692<dt><pre>
693DdNode * <i></i>
694<a name="Cudd_CubeArrayToBdd"><b>Cudd_CubeArrayToBdd</b></a>(
695  DdManager * <b>dd</b>, <i></i>
696  int * <b>array</b> <i></i>
697)
698</pre>
699<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.
700<p>
701
702<dd> <b>Side Effects</b> None
703<p>
704
705<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_bddComputeCube">Cudd_bddComputeCube</a>
706<a href="cuddAllDet.html#Cudd_IndicesToCube">Cudd_IndicesToCube</a>
707<a href="cuddAllDet.html#Cudd_BddToCubeArray">Cudd_BddToCubeArray</a>
708</code>
709
710<dt><pre>
711int <i></i>
712<a name="Cudd_DagSize"><b>Cudd_DagSize</b></a>(
713  DdNode * <b>node</b> <i></i>
714)
715</pre>
716<dd> Counts the number of nodes in a DD. Returns the number of nodes in the graph rooted at node.
717<p>
718
719<dd> <b>Side Effects</b> None
720<p>
721
722<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_SharingSize">Cudd_SharingSize</a>
723<a href="cuddAllDet.html#Cudd_PrintDebug">Cudd_PrintDebug</a>
724</code>
725
726<dt><pre>
727int <i></i>
728<a name="Cudd_DeadAreCounted"><b>Cudd_DeadAreCounted</b></a>(
729  DdManager * <b>dd</b> <i></i>
730)
731</pre>
732<dd> Tells whether dead nodes are counted towards triggering reordering. Returns 1 if dead nodes are counted; 0 otherwise.
733<p>
734
735<dd> <b>Side Effects</b> None
736<p>
737
738<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_TurnOnCountDead">Cudd_TurnOnCountDead</a>
739<a href="cuddAllDet.html#Cudd_TurnOffCountDead">Cudd_TurnOffCountDead</a>
740</code>
741
742<dt><pre>
743int <i></i>
744<a name="Cudd_DebugCheck"><b>Cudd_DebugCheck</b></a>(
745  DdManager * <b>table</b> <i></i>
746)
747</pre>
748<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.
749<p>
750
751<dd> <b>Side Effects</b> None
752<p>
753
754<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_CheckKeys">Cudd_CheckKeys</a>
755</code>
756
757<dt><pre>
758DdNode * <i></i>
759<a name="Cudd_Decreasing"><b>Cudd_Decreasing</b></a>(
760  DdManager * <b>dd</b>, <i></i>
761  DdNode * <b>f</b>, <i></i>
762  int  <b>i</b> <i></i>
763)
764</pre>
765<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.
766<p>
767
768<dd> <b>Side Effects</b> None
769<p>
770
771<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_Increasing">Cudd_Increasing</a>
772</code>
773
774<dt><pre>
775void <i></i>
776<a name="Cudd_DelayedDerefBdd"><b>Cudd_DelayedDerefBdd</b></a>(
777  DdManager * <b>table</b>, <i></i>
778  DdNode * <b>n</b> <i></i>
779)
780</pre>
781<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.
782<p>
783
784<dd> <b>Side Effects</b> None
785<p>
786
787<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_RecursiveDeref">Cudd_RecursiveDeref</a>
788<a href="cuddAllDet.html#Cudd_IterDerefBdd">Cudd_IterDerefBdd</a>
789</code>
790
791<dt><pre>
792double <i></i>
793<a name="Cudd_Density"><b>Cudd_Density</b></a>(
794  DdManager * <b>dd</b>, <i>manager</i>
795  DdNode * <b>f</b>, <i>function whose density is sought</i>
796  int  <b>nvars</b> <i>size of the support of f</i>
797)
798</pre>
799<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.
800<p>
801
802<dd> <b>Side Effects</b> None
803<p>
804
805<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_CountMinterm">Cudd_CountMinterm</a>
806<a href="cuddAllDet.html#Cudd_DagSize">Cudd_DagSize</a>
807</code>
808
809<dt><pre>
810void <i></i>
811<a name="Cudd_Deref"><b>Cudd_Deref</b></a>(
812  DdNode * <b>node</b> <i></i>
813)
814</pre>
815<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.
816<p>
817
818<dd> <b>Side Effects</b> None
819<p>
820
821<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_RecursiveDeref">Cudd_RecursiveDeref</a>
822<a href="cuddAllDet.html#Cudd_RecursiveDerefZdd">Cudd_RecursiveDerefZdd</a>
823<a href="cuddAllDet.html#Cudd_Ref">Cudd_Ref</a>
824</code>
825
826<dt><pre>
827void <i></i>
828<a name="Cudd_DisableGarbageCollection"><b>Cudd_DisableGarbageCollection</b></a>(
829  DdManager * <b>dd</b> <i></i>
830)
831</pre>
832<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.)
833<p>
834
835<dd> <b>Side Effects</b> None
836<p>
837
838<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_EnableGarbageCollection">Cudd_EnableGarbageCollection</a>
839<a href="cuddAllDet.html#Cudd_GarbageCollectionEnabled">Cudd_GarbageCollectionEnabled</a>
840</code>
841
842<dt><pre>
843int <i></i>
844<a name="Cudd_DisableReorderingReporting"><b>Cudd_DisableReorderingReporting</b></a>(
845  DdManager * <b>dd</b> <i></i>
846)
847</pre>
848<dd> Disables reporting of reordering stats. Returns 1 if successful; 0 otherwise.
849<p>
850
851<dd> <b>Side Effects</b> Removes functions from the pre-reordering and post-reordering hooks.
852<p>
853
854<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_EnableReorderingReporting">Cudd_EnableReorderingReporting</a>
855<a href="cuddAllDet.html#Cudd_ReorderingReporting">Cudd_ReorderingReporting</a>
856</code>
857
858<dt><pre>
859int <i></i>
860<a name="Cudd_DumpBlifBody"><b>Cudd_DumpBlifBody</b></a>(
861  DdManager * <b>dd</b>, <i>manager</i>
862  int  <b>n</b>, <i>number of output nodes to be dumped</i>
863  DdNode ** <b>f</b>, <i>array of output nodes to be dumped</i>
864  char ** <b>inames</b>, <i>array of input names (or NULL)</i>
865  char ** <b>onames</b>, <i>array of output names (or NULL)</i>
866  FILE * <b>fp</b> <i>pointer to the dump file</i>
867)
868</pre>
869<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.
870<p>
871
872<dd> <b>Side Effects</b> None
873<p>
874
875<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_DumpBlif">Cudd_DumpBlif</a>
876<a href="cuddAllDet.html#Cudd_DumpDot">Cudd_DumpDot</a>
877<a href="cuddAllDet.html#Cudd_PrintDebug">Cudd_PrintDebug</a>
878<a href="cuddAllDet.html#Cudd_DumpDDcal">Cudd_DumpDDcal</a>
879<a href="cuddAllDet.html#Cudd_DumpDaVinci">Cudd_DumpDaVinci</a>
880<a href="cuddAllDet.html#Cudd_DumpFactoredForm">Cudd_DumpFactoredForm</a>
881</code>
882
883<dt><pre>
884int <i></i>
885<a name="Cudd_DumpBlif"><b>Cudd_DumpBlif</b></a>(
886  DdManager * <b>dd</b>, <i>manager</i>
887  int  <b>n</b>, <i>number of output nodes to be dumped</i>
888  DdNode ** <b>f</b>, <i>array of output nodes to be dumped</i>
889  char ** <b>inames</b>, <i>array of input names (or NULL)</i>
890  char ** <b>onames</b>, <i>array of output names (or NULL)</i>
891  char * <b>mname</b>, <i>model name (or NULL)</i>
892  FILE * <b>fp</b> <i>pointer to the dump file</i>
893)
894</pre>
895<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.
896<p>
897
898<dd> <b>Side Effects</b> None
899<p>
900
901<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_DumpBlifBody">Cudd_DumpBlifBody</a>
902<a href="cuddAllDet.html#Cudd_DumpDot">Cudd_DumpDot</a>
903<a href="cuddAllDet.html#Cudd_PrintDebug">Cudd_PrintDebug</a>
904<a href="cuddAllDet.html#Cudd_DumpDDcal">Cudd_DumpDDcal</a>
905<a href="cuddAllDet.html#Cudd_DumpDaVinci">Cudd_DumpDaVinci</a>
906<a href="cuddAllDet.html#Cudd_DumpFactoredForm">Cudd_DumpFactoredForm</a>
907</code>
908
909<dt><pre>
910int <i></i>
911<a name="Cudd_DumpDDcal"><b>Cudd_DumpDDcal</b></a>(
912  DdManager * <b>dd</b>, <i>manager</i>
913  int  <b>n</b>, <i>number of output nodes to be dumped</i>
914  DdNode ** <b>f</b>, <i>array of output nodes to be dumped</i>
915  char ** <b>inames</b>, <i>array of input names (or NULL)</i>
916  char ** <b>onames</b>, <i>array of output names (or NULL)</i>
917  FILE * <b>fp</b> <i>pointer to the dump file</i>
918)
919</pre>
920<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.
921<p>
922
923<dd> <b>Side Effects</b> None
924<p>
925
926<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_DumpDot">Cudd_DumpDot</a>
927<a href="cuddAllDet.html#Cudd_PrintDebug">Cudd_PrintDebug</a>
928<a href="cuddAllDet.html#Cudd_DumpBlif">Cudd_DumpBlif</a>
929<a href="cuddAllDet.html#Cudd_DumpDaVinci">Cudd_DumpDaVinci</a>
930<a href="cuddAllDet.html#Cudd_DumpFactoredForm">Cudd_DumpFactoredForm</a>
931</code>
932
933<dt><pre>
934int <i></i>
935<a name="Cudd_DumpDaVinci"><b>Cudd_DumpDaVinci</b></a>(
936  DdManager * <b>dd</b>, <i>manager</i>
937  int  <b>n</b>, <i>number of output nodes to be dumped</i>
938  DdNode ** <b>f</b>, <i>array of output nodes to be dumped</i>
939  char ** <b>inames</b>, <i>array of input names (or NULL)</i>
940  char ** <b>onames</b>, <i>array of output names (or NULL)</i>
941  FILE * <b>fp</b> <i>pointer to the dump file</i>
942)
943</pre>
944<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.
945<p>
946
947<dd> <b>Side Effects</b> None
948<p>
949
950<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_DumpDot">Cudd_DumpDot</a>
951<a href="cuddAllDet.html#Cudd_PrintDebug">Cudd_PrintDebug</a>
952<a href="cuddAllDet.html#Cudd_DumpBlif">Cudd_DumpBlif</a>
953<a href="cuddAllDet.html#Cudd_DumpDDcal">Cudd_DumpDDcal</a>
954<a href="cuddAllDet.html#Cudd_DumpFactoredForm">Cudd_DumpFactoredForm</a>
955</code>
956
957<dt><pre>
958int <i></i>
959<a name="Cudd_DumpDot"><b>Cudd_DumpDot</b></a>(
960  DdManager * <b>dd</b>, <i>manager</i>
961  int  <b>n</b>, <i>number of output nodes to be dumped</i>
962  DdNode ** <b>f</b>, <i>array of output nodes to be dumped</i>
963  char ** <b>inames</b>, <i>array of input names (or NULL)</i>
964  char ** <b>onames</b>, <i>array of output names (or NULL)</i>
965  FILE * <b>fp</b> <i>pointer to the dump file</i>
966)
967</pre>
968<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.
969<p>
970
971<dd> <b>Side Effects</b> None
972<p>
973
974<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_DumpBlif">Cudd_DumpBlif</a>
975<a href="cuddAllDet.html#Cudd_PrintDebug">Cudd_PrintDebug</a>
976<a href="cuddAllDet.html#Cudd_DumpDDcal">Cudd_DumpDDcal</a>
977<a href="cuddAllDet.html#Cudd_DumpDaVinci">Cudd_DumpDaVinci</a>
978<a href="cuddAllDet.html#Cudd_DumpFactoredForm">Cudd_DumpFactoredForm</a>
979</code>
980
981<dt><pre>
982int <i></i>
983<a name="Cudd_DumpFactoredForm"><b>Cudd_DumpFactoredForm</b></a>(
984  DdManager * <b>dd</b>, <i>manager</i>
985  int  <b>n</b>, <i>number of output nodes to be dumped</i>
986  DdNode ** <b>f</b>, <i>array of output nodes to be dumped</i>
987  char ** <b>inames</b>, <i>array of input names (or NULL)</i>
988  char ** <b>onames</b>, <i>array of output names (or NULL)</i>
989  FILE * <b>fp</b> <i>pointer to the dump file</i>
990)
991</pre>
992<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.
993<p>
994
995<dd> <b>Side Effects</b> None
996<p>
997
998<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_DumpDot">Cudd_DumpDot</a>
999<a href="cuddAllDet.html#Cudd_PrintDebug">Cudd_PrintDebug</a>
1000<a href="cuddAllDet.html#Cudd_DumpBlif">Cudd_DumpBlif</a>
1001<a href="cuddAllDet.html#Cudd_DumpDaVinci">Cudd_DumpDaVinci</a>
1002<a href="cuddAllDet.html#Cudd_DumpDDcal">Cudd_DumpDDcal</a>
1003</code>
1004
1005<dt><pre>
1006DdNode * <i></i>
1007<a name="Cudd_Dxygtdxz"><b>Cudd_Dxygtdxz</b></a>(
1008  DdManager * <b>dd</b>, <i>DD manager</i>
1009  int  <b>N</b>, <i>number of x, y, and z variables</i>
1010  DdNode ** <b>x</b>, <i>array of x variables</i>
1011  DdNode ** <b>y</b>, <i>array of y variables</i>
1012  DdNode ** <b>z</b> <i>array of z variables</i>
1013)
1014</pre>
1015<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].
1016<p>
1017
1018<dd> <b>Side Effects</b> None
1019<p>
1020
1021<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_PrioritySelect">Cudd_PrioritySelect</a>
1022<a href="cuddAllDet.html#Cudd_Dxygtdyz">Cudd_Dxygtdyz</a>
1023<a href="cuddAllDet.html#Cudd_Xgty">Cudd_Xgty</a>
1024<a href="cuddAllDet.html#Cudd_bddAdjPermuteX">Cudd_bddAdjPermuteX</a>
1025</code>
1026
1027<dt><pre>
1028DdNode * <i></i>
1029<a name="Cudd_Dxygtdyz"><b>Cudd_Dxygtdyz</b></a>(
1030  DdManager * <b>dd</b>, <i>DD manager</i>
1031  int  <b>N</b>, <i>number of x, y, and z variables</i>
1032  DdNode ** <b>x</b>, <i>array of x variables</i>
1033  DdNode ** <b>y</b>, <i>array of y variables</i>
1034  DdNode ** <b>z</b> <i>array of z variables</i>
1035)
1036</pre>
1037<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].
1038<p>
1039
1040<dd> <b>Side Effects</b> None
1041<p>
1042
1043<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_PrioritySelect">Cudd_PrioritySelect</a>
1044<a href="cuddAllDet.html#Cudd_Dxygtdxz">Cudd_Dxygtdxz</a>
1045<a href="cuddAllDet.html#Cudd_Xgty">Cudd_Xgty</a>
1046<a href="cuddAllDet.html#Cudd_bddAdjPermuteX">Cudd_bddAdjPermuteX</a>
1047</code>
1048
1049<dt><pre>
1050void <i></i>
1051<a name="Cudd_EnableGarbageCollection"><b>Cudd_EnableGarbageCollection</b></a>(
1052  DdManager * <b>dd</b> <i></i>
1053)
1054</pre>
1055<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.
1056<p>
1057
1058<dd> <b>Side Effects</b> None
1059<p>
1060
1061<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_DisableGarbageCollection">Cudd_DisableGarbageCollection</a>
1062<a href="cuddAllDet.html#Cudd_GarbageCollectionEnabled">Cudd_GarbageCollectionEnabled</a>
1063</code>
1064
1065<dt><pre>
1066int <i></i>
1067<a name="Cudd_EnableReorderingReporting"><b>Cudd_EnableReorderingReporting</b></a>(
1068  DdManager * <b>dd</b> <i></i>
1069)
1070</pre>
1071<dd> Enables reporting of reordering stats. Returns 1 if successful; 0 otherwise.
1072<p>
1073
1074<dd> <b>Side Effects</b> Installs functions in the pre-reordering and post-reordering hooks.
1075<p>
1076
1077<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_DisableReorderingReporting">Cudd_DisableReorderingReporting</a>
1078<a href="cuddAllDet.html#Cudd_ReorderingReporting">Cudd_ReorderingReporting</a>
1079</code>
1080
1081<dt><pre>
1082int <i></i>
1083<a name="Cudd_EpdCountMinterm"><b>Cudd_EpdCountMinterm</b></a>(
1084  DdManager * <b>manager</b>, <i></i>
1085  DdNode * <b>node</b>, <i></i>
1086  int  <b>nvars</b>, <i></i>
1087  EpDouble * <b>epd</b> <i></i>
1088)
1089</pre>
1090<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.
1091<p>
1092
1093<dd> <b>Side Effects</b> None
1094<p>
1095
1096<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_PrintDebug">Cudd_PrintDebug</a>
1097<a href="cuddAllDet.html#Cudd_CountPath">Cudd_CountPath</a>
1098</code>
1099
1100<dt><pre>
1101int <i></i>
1102<a name="Cudd_EqualSupNorm"><b>Cudd_EqualSupNorm</b></a>(
1103  DdManager * <b>dd</b>, <i>manager</i>
1104  DdNode * <b>f</b>, <i>first ADD</i>
1105  DdNode * <b>g</b>, <i>second ADD</i>
1106  CUDD_VALUE_TYPE  <b>tolerance</b>, <i>maximum allowed difference</i>
1107  int  <b>pr</b> <i>verbosity level</i>
1108)
1109</pre>
1110<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.
1111<p>
1112
1113<dd> <b>Side Effects</b> None
1114<p>
1115
1116<dt><pre>
1117int <i></i>
1118<a name="Cudd_EquivDC"><b>Cudd_EquivDC</b></a>(
1119  DdManager * <b>dd</b>, <i></i>
1120  DdNode * <b>F</b>, <i></i>
1121  DdNode * <b>G</b>, <i></i>
1122  DdNode * <b>D</b> <i></i>
1123)
1124</pre>
1125<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.
1126<p>
1127
1128<dd> <b>Side Effects</b> None
1129<p>
1130
1131<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_bddLeqUnless">Cudd_bddLeqUnless</a>
1132</code>
1133
1134<dt><pre>
1135int <i></i>
1136<a name="Cudd_EstimateCofactorSimple"><b>Cudd_EstimateCofactorSimple</b></a>(
1137  DdNode * <b>node</b>, <i></i>
1138  int  <b>i</b> <i></i>
1139)
1140</pre>
1141<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.
1142<p>
1143
1144<dd> <b>Side Effects</b> None
1145<p>
1146
1147<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_DagSize">Cudd_DagSize</a>
1148</code>
1149
1150<dt><pre>
1151int <i></i>
1152<a name="Cudd_EstimateCofactor"><b>Cudd_EstimateCofactor</b></a>(
1153  DdManager * <b>dd</b>, <i>manager</i>
1154  DdNode * <b>f</b>, <i>function</i>
1155  int  <b>i</b>, <i>index of variable</i>
1156  int  <b>phase</b> <i>1: positive; 0: negative</i>
1157)
1158</pre>
1159<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.
1160<p>
1161
1162<dd> <b>Side Effects</b> None
1163<p>
1164
1165<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_DagSize">Cudd_DagSize</a>
1166<a href="cuddAllDet.html#Cudd_EstimateCofactorSimple">Cudd_EstimateCofactorSimple</a>
1167</code>
1168
1169<dt><pre>
1170DdNode * <i></i>
1171<a name="Cudd_Eval"><b>Cudd_Eval</b></a>(
1172  DdManager * <b>dd</b>, <i></i>
1173  DdNode * <b>f</b>, <i></i>
1174  int * <b>inputs</b> <i></i>
1175)
1176</pre>
1177<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.
1178<p>
1179
1180<dd> <b>Side Effects</b> None
1181<p>
1182
1183<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_bddLeq">Cudd_bddLeq</a>
1184<a href="cuddAllDet.html#Cudd_addEvalConst">Cudd_addEvalConst</a>
1185</code>
1186
1187<dt><pre>
1188double <i></i>
1189<a name="Cudd_ExpectedUsedSlots"><b>Cudd_ExpectedUsedSlots</b></a>(
1190  DdManager * <b>dd</b> <i></i>
1191)
1192</pre>
1193<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.
1194<p>
1195
1196<dd> <b>Side Effects</b> None
1197<p>
1198
1199<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_ReadSlots">Cudd_ReadSlots</a>
1200<a href="cuddAllDet.html#Cudd_ReadUsedSlots">Cudd_ReadUsedSlots</a>
1201</code>
1202
1203<dt><pre>
1204 <i></i>
1205<a name="Cudd_E"><b>Cudd_E</b></a>(
1206   <b>node</b> <i></i>
1207)
1208</pre>
1209<dd> Returns the else child of an internal node. If <code>node</code> is a constant node, the result is unpredictable.
1210<p>
1211
1212<dd> <b>Side Effects</b> none
1213<p>
1214
1215<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_T">Cudd_T</a>
1216<a href="cuddAllDet.html#Cudd_V">Cudd_V</a>
1217</code>
1218
1219<dt><pre>
1220DdNode * <i></i>
1221<a name="Cudd_FindEssential"><b>Cudd_FindEssential</b></a>(
1222  DdManager * <b>dd</b>, <i></i>
1223  DdNode * <b>f</b> <i></i>
1224)
1225</pre>
1226<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.
1227<p>
1228
1229<dd> <b>Side Effects</b> None
1230<p>
1231
1232<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_bddIsVarEssential">Cudd_bddIsVarEssential</a>
1233</code>
1234
1235<dt><pre>
1236DdTlcInfo * <i></i>
1237<a name="Cudd_FindTwoLiteralClauses"><b>Cudd_FindTwoLiteralClauses</b></a>(
1238  DdManager * <b>dd</b>, <i></i>
1239  DdNode * <b>f</b> <i></i>
1240)
1241</pre>
1242<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.
1243<p>
1244
1245<dd> <b>Side Effects</b> None
1246<p>
1247
1248<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_FindEssential">Cudd_FindEssential</a>
1249</code>
1250
1251<dt><pre>
1252DdGen * <i></i>
1253<a name="Cudd_FirstCube"><b>Cudd_FirstCube</b></a>(
1254  DdManager * <b>dd</b>, <i></i>
1255  DdNode * <b>f</b>, <i></i>
1256  int ** <b>cube</b>, <i></i>
1257  CUDD_VALUE_TYPE * <b>value</b> <i></i>
1258)
1259</pre>
1260<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.
1261<p>
1262
1263<dd> <b>Side Effects</b> The first cube and its value are returned as side effects.
1264<p>
1265
1266<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_ForeachCube">Cudd_ForeachCube</a>
1267<a href="cuddAllDet.html#Cudd_NextCube">Cudd_NextCube</a>
1268<a href="cuddAllDet.html#Cudd_GenFree">Cudd_GenFree</a>
1269<a href="cuddAllDet.html#Cudd_IsGenEmpty">Cudd_IsGenEmpty</a>
1270<a href="cuddAllDet.html#Cudd_FirstNode">Cudd_FirstNode</a>
1271</code>
1272
1273<dt><pre>
1274DdGen * <i></i>
1275<a name="Cudd_FirstNode"><b>Cudd_FirstNode</b></a>(
1276  DdManager * <b>dd</b>, <i></i>
1277  DdNode * <b>f</b>, <i></i>
1278  DdNode ** <b>node</b> <i></i>
1279)
1280</pre>
1281<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.
1282<p>
1283
1284<dd> <b>Side Effects</b> The first node is returned as a side effect.
1285<p>
1286
1287<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_ForeachNode">Cudd_ForeachNode</a>
1288<a href="cuddAllDet.html#Cudd_NextNode">Cudd_NextNode</a>
1289<a href="cuddAllDet.html#Cudd_GenFree">Cudd_GenFree</a>
1290<a href="cuddAllDet.html#Cudd_IsGenEmpty">Cudd_IsGenEmpty</a>
1291<a href="cuddAllDet.html#Cudd_FirstCube">Cudd_FirstCube</a>
1292</code>
1293
1294<dt><pre>
1295DdGen * <i></i>
1296<a name="Cudd_FirstPrime"><b>Cudd_FirstPrime</b></a>(
1297  DdManager * <b>dd</b>, <i></i>
1298  DdNode * <b>l</b>, <i></i>
1299  DdNode * <b>u</b>, <i></i>
1300  int ** <b>cube</b> <i></i>
1301)
1302</pre>
1303<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.
1304<p>
1305
1306<dd> <b>Side Effects</b> The first cube is returned as side effect.
1307<p>
1308
1309<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_ForeachPrime">Cudd_ForeachPrime</a>
1310<a href="cuddAllDet.html#Cudd_NextPrime">Cudd_NextPrime</a>
1311<a href="cuddAllDet.html#Cudd_GenFree">Cudd_GenFree</a>
1312<a href="cuddAllDet.html#Cudd_IsGenEmpty">Cudd_IsGenEmpty</a>
1313<a href="cuddAllDet.html#Cudd_FirstCube">Cudd_FirstCube</a>
1314<a href="cuddAllDet.html#Cudd_FirstNode">Cudd_FirstNode</a>
1315</code>
1316
1317<dt><pre>
1318 <i></i>
1319<a name="Cudd_ForeachCube"><b>Cudd_ForeachCube</b></a>(
1320   <b>manager</b>, <i></i>
1321   <b>f</b>, <i></i>
1322   <b>gen</b>, <i></i>
1323   <b>cube</b>, <i></i>
1324   <b>value</b> <i></i>
1325)
1326</pre>
1327<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.
1328<p>
1329
1330<dd> <b>Side Effects</b> none
1331<p>
1332
1333<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_ForeachNode">Cudd_ForeachNode</a>
1334<a href="cuddAllDet.html#Cudd_FirstCube">Cudd_FirstCube</a>
1335<a href="cuddAllDet.html#Cudd_NextCube">Cudd_NextCube</a>
1336<a href="cuddAllDet.html#Cudd_GenFree">Cudd_GenFree</a>
1337<a href="cuddAllDet.html#Cudd_IsGenEmpty">Cudd_IsGenEmpty</a>
1338<a href="cuddAllDet.html#Cudd_AutodynDisable">Cudd_AutodynDisable</a>
1339</code>
1340
1341<dt><pre>
1342 <i></i>
1343<a name="Cudd_ForeachNode"><b>Cudd_ForeachNode</b></a>(
1344   <b>manager</b>, <i></i>
1345   <b>f</b>, <i></i>
1346   <b>gen</b>, <i></i>
1347   <b>node</b> <i></i>
1348)
1349</pre>
1350<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.
1351<p>
1352
1353<dd> <b>Side Effects</b> none
1354<p>
1355
1356<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_ForeachCube">Cudd_ForeachCube</a>
1357<a href="cuddAllDet.html#Cudd_FirstNode">Cudd_FirstNode</a>
1358<a href="cuddAllDet.html#Cudd_NextNode">Cudd_NextNode</a>
1359<a href="cuddAllDet.html#Cudd_GenFree">Cudd_GenFree</a>
1360<a href="cuddAllDet.html#Cudd_IsGenEmpty">Cudd_IsGenEmpty</a>
1361<a href="cuddAllDet.html#Cudd_AutodynDisable">Cudd_AutodynDisable</a>
1362</code>
1363
1364<dt><pre>
1365 <i></i>
1366<a name="Cudd_ForeachPrime"><b>Cudd_ForeachPrime</b></a>(
1367   <b>manager</b>, <i></i>
1368   <b>l</b>, <i></i>
1369   <b>u</b>, <i></i>
1370   <b>gen</b>, <i></i>
1371   <b>cube</b> <i></i>
1372)
1373</pre>
1374<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.
1375<p>
1376
1377<dd> <b>Side Effects</b> none
1378<p>
1379
1380<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_ForeachCube">Cudd_ForeachCube</a>
1381<a href="cuddAllDet.html#Cudd_FirstPrime">Cudd_FirstPrime</a>
1382<a href="cuddAllDet.html#Cudd_NextPrime">Cudd_NextPrime</a>
1383<a href="cuddAllDet.html#Cudd_GenFree">Cudd_GenFree</a>
1384<a href="cuddAllDet.html#Cudd_IsGenEmpty">Cudd_IsGenEmpty</a>
1385</code>
1386
1387<dt><pre>
1388void <i></i>
1389<a name="Cudd_FreeTree"><b>Cudd_FreeTree</b></a>(
1390  DdManager * <b>dd</b> <i></i>
1391)
1392</pre>
1393<dd> Frees the variable group tree of the manager.
1394<p>
1395
1396<dd> <b>Side Effects</b> None
1397<p>
1398
1399<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_SetTree">Cudd_SetTree</a>
1400<a href="cuddAllDet.html#Cudd_ReadTree">Cudd_ReadTree</a>
1401<a href="cuddAllDet.html#Cudd_FreeZddTree">Cudd_FreeZddTree</a>
1402</code>
1403
1404<dt><pre>
1405void <i></i>
1406<a name="Cudd_FreeZddTree"><b>Cudd_FreeZddTree</b></a>(
1407  DdManager * <b>dd</b> <i></i>
1408)
1409</pre>
1410<dd> Frees the variable group tree of the manager.
1411<p>
1412
1413<dd> <b>Side Effects</b> None
1414<p>
1415
1416<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_SetZddTree">Cudd_SetZddTree</a>
1417<a href="cuddAllDet.html#Cudd_ReadZddTree">Cudd_ReadZddTree</a>
1418<a href="cuddAllDet.html#Cudd_FreeTree">Cudd_FreeTree</a>
1419</code>
1420
1421<dt><pre>
1422int <i></i>
1423<a name="Cudd_GarbageCollectionEnabled"><b>Cudd_GarbageCollectionEnabled</b></a>(
1424  DdManager * <b>dd</b> <i></i>
1425)
1426</pre>
1427<dd> Returns 1 if garbage collection is enabled; 0 otherwise.
1428<p>
1429
1430<dd> <b>Side Effects</b> None
1431<p>
1432
1433<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_EnableGarbageCollection">Cudd_EnableGarbageCollection</a>
1434<a href="cuddAllDet.html#Cudd_DisableGarbageCollection">Cudd_DisableGarbageCollection</a>
1435</code>
1436
1437<dt><pre>
1438int <i></i>
1439<a name="Cudd_GenFree"><b>Cudd_GenFree</b></a>(
1440  DdGen * <b>gen</b> <i></i>
1441)
1442</pre>
1443<dd> Frees a CUDD generator. Always returns 0, so that it can be used in mis-like foreach constructs.
1444<p>
1445
1446<dd> <b>Side Effects</b> None
1447<p>
1448
1449<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_ForeachCube">Cudd_ForeachCube</a>
1450<a href="cuddAllDet.html#Cudd_ForeachNode">Cudd_ForeachNode</a>
1451<a href="cuddAllDet.html#Cudd_FirstCube">Cudd_FirstCube</a>
1452<a href="cuddAllDet.html#Cudd_NextCube">Cudd_NextCube</a>
1453<a href="cuddAllDet.html#Cudd_FirstNode">Cudd_FirstNode</a>
1454<a href="cuddAllDet.html#Cudd_NextNode">Cudd_NextNode</a>
1455<a href="cuddAllDet.html#Cudd_IsGenEmpty">Cudd_IsGenEmpty</a>
1456</code>
1457
1458<dt><pre>
1459DdNode * <i></i>
1460<a name="Cudd_Increasing"><b>Cudd_Increasing</b></a>(
1461  DdManager * <b>dd</b>, <i></i>
1462  DdNode * <b>f</b>, <i></i>
1463  int  <b>i</b> <i></i>
1464)
1465</pre>
1466<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.
1467<p>
1468
1469<dd> <b>Side Effects</b> None
1470<p>
1471
1472<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_Decreasing">Cudd_Decreasing</a>
1473</code>
1474
1475<dt><pre>
1476DdNode * <i></i>
1477<a name="Cudd_IndicesToCube"><b>Cudd_IndicesToCube</b></a>(
1478  DdManager * <b>dd</b>, <i></i>
1479  int * <b>array</b>, <i></i>
1480  int  <b>n</b> <i></i>
1481)
1482</pre>
1483<dd> Builds a cube of BDD variables from an array of indices. Returns a pointer to the result if successful; NULL otherwise.
1484<p>
1485
1486<dd> <b>Side Effects</b> None
1487<p>
1488
1489<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_bddComputeCube">Cudd_bddComputeCube</a>
1490<a href="cuddAllDet.html#Cudd_CubeArrayToBdd">Cudd_CubeArrayToBdd</a>
1491</code>
1492
1493<dt><pre>
1494DdManager * <i></i>
1495<a name="Cudd_Init"><b>Cudd_Init</b></a>(
1496  unsigned int  <b>numVars</b>, <i>initial number of BDD variables (i.e., subtables)</i>
1497  unsigned int  <b>numVarsZ</b>, <i>initial number of ZDD variables (i.e., subtables)</i>
1498  unsigned int  <b>numSlots</b>, <i>initial size of the unique tables</i>
1499  unsigned int  <b>cacheSize</b>, <i>initial size of the cache</i>
1500  unsigned long  <b>maxMemory</b> <i>target maximum memory occupation</i>
1501)
1502</pre>
1503<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.
1504<p>
1505
1506<dd> <b>Side Effects</b> None
1507<p>
1508
1509<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_Quit">Cudd_Quit</a>
1510</code>
1511
1512<dt><pre>
1513 <i></i>
1514<a name="Cudd_IsComplement"><b>Cudd_IsComplement</b></a>(
1515   <b>node</b> <i></i>
1516)
1517</pre>
1518<dd> Returns 1 if a pointer is complemented.
1519<p>
1520
1521<dd> <b>Side Effects</b> none
1522<p>
1523
1524<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_Regular">Cudd_Regular</a>
1525<a href="cuddAllDet.html#Cudd_Complement">Cudd_Complement</a>
1526</code>
1527
1528<dt><pre>
1529 <i></i>
1530<a name="Cudd_IsConstant"><b>Cudd_IsConstant</b></a>(
1531   <b>node</b> <i></i>
1532)
1533</pre>
1534<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.
1535<p>
1536
1537<dd> <b>Side Effects</b> none
1538<p>
1539
1540<dt><pre>
1541int <i></i>
1542<a name="Cudd_IsGenEmpty"><b>Cudd_IsGenEmpty</b></a>(
1543  DdGen * <b>gen</b> <i></i>
1544)
1545</pre>
1546<dd> Queries the status of a generator. Returns 1 if the generator is empty or NULL; 0 otherswise.
1547<p>
1548
1549<dd> <b>Side Effects</b> None
1550<p>
1551
1552<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_ForeachCube">Cudd_ForeachCube</a>
1553<a href="cuddAllDet.html#Cudd_ForeachNode">Cudd_ForeachNode</a>
1554<a href="cuddAllDet.html#Cudd_FirstCube">Cudd_FirstCube</a>
1555<a href="cuddAllDet.html#Cudd_NextCube">Cudd_NextCube</a>
1556<a href="cuddAllDet.html#Cudd_FirstNode">Cudd_FirstNode</a>
1557<a href="cuddAllDet.html#Cudd_NextNode">Cudd_NextNode</a>
1558<a href="cuddAllDet.html#Cudd_GenFree">Cudd_GenFree</a>
1559</code>
1560
1561<dt><pre>
1562int <i></i>
1563<a name="Cudd_IsInHook"><b>Cudd_IsInHook</b></a>(
1564  DdManager * <b>dd</b>, <i></i>
1565  DD_HFP  <b>f</b>, <i></i>
1566  Cudd_HookType  <b>where</b> <i></i>
1567)
1568</pre>
1569<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.
1570<p>
1571
1572<dd> <b>Side Effects</b> None
1573<p>
1574
1575<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_AddHook">Cudd_AddHook</a>
1576<a href="cuddAllDet.html#Cudd_RemoveHook">Cudd_RemoveHook</a>
1577</code>
1578
1579<dt><pre>
1580int <i></i>
1581<a name="Cudd_IsNonConstant"><b>Cudd_IsNonConstant</b></a>(
1582  DdNode * <b>f</b> <i></i>
1583)
1584</pre>
1585<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.
1586<p>
1587
1588<dd> <b>Side Effects</b> None
1589<p>
1590
1591<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_IsConstant">Cudd_IsConstant</a>
1592<a href="cuddAllDet.html#Cudd_bddIteConstant">Cudd_bddIteConstant</a>
1593<a href="cuddAllDet.html#Cudd_addIteConstant">Cudd_addIteConstant</a>
1594<a href="cuddAllDet.html#Cudd_addEvalConst">Cudd_addEvalConst</a>
1595</code>
1596
1597<dt><pre>
1598void <i></i>
1599<a name="Cudd_IterDerefBdd"><b>Cudd_IterDerefBdd</b></a>(
1600  DdManager * <b>table</b>, <i></i>
1601  DdNode * <b>n</b> <i></i>
1602)
1603</pre>
1604<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.
1605<p>
1606
1607<dd> <b>Side Effects</b> None
1608<p>
1609
1610<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_RecursiveDeref">Cudd_RecursiveDeref</a>
1611<a href="cuddAllDet.html#Cudd_DelayedDerefBdd">Cudd_DelayedDerefBdd</a>
1612</code>
1613
1614<dt><pre>
1615DdNode * <i></i>
1616<a name="Cudd_LargestCube"><b>Cudd_LargestCube</b></a>(
1617  DdManager * <b>manager</b>, <i></i>
1618  DdNode * <b>f</b>, <i></i>
1619  int * <b>length</b> <i></i>
1620)
1621</pre>
1622<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.
1623<p>
1624
1625<dd> <b>Side Effects</b> The number of literals of the cube is returned in length.
1626<p>
1627
1628<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_ShortestPath">Cudd_ShortestPath</a>
1629</code>
1630
1631<dt><pre>
1632DdNode  * <i></i>
1633<a name="Cudd_MakeBddFromZddCover"><b>Cudd_MakeBddFromZddCover</b></a>(
1634  DdManager * <b>dd</b>, <i></i>
1635  DdNode * <b>node</b> <i></i>
1636)
1637</pre>
1638<dd> Converts a ZDD cover to a BDD graph. If successful, it returns a BDD node, otherwise it returns NULL.
1639<p>
1640
1641<dd> <b>See Also</b> <code><a href="cuddAllDet.html#cuddMakeBddFromZddCover">cuddMakeBddFromZddCover</a>
1642</code>
1643
1644<dt><pre>
1645MtrNode * <i></i>
1646<a name="Cudd_MakeTreeNode"><b>Cudd_MakeTreeNode</b></a>(
1647  DdManager * <b>dd</b>, <i>manager</i>
1648  unsigned int  <b>low</b>, <i>index of the first group variable</i>
1649  unsigned int  <b>size</b>, <i>number of variables in the group</i>
1650  unsigned int  <b>type</b> <i>MTR_DEFAULT or MTR_FIXED</i>
1651)
1652</pre>
1653<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.
1654<p>
1655
1656<dd> <b>Side Effects</b> The variable tree is changed.
1657<p>
1658
1659<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_MakeZddTreeNode">Cudd_MakeZddTreeNode</a>
1660</code>
1661
1662<dt><pre>
1663MtrNode * <i></i>
1664<a name="Cudd_MakeZddTreeNode"><b>Cudd_MakeZddTreeNode</b></a>(
1665  DdManager * <b>dd</b>, <i>manager</i>
1666  unsigned int  <b>low</b>, <i>index of the first group variable</i>
1667  unsigned int  <b>size</b>, <i>number of variables in the group</i>
1668  unsigned int  <b>type</b> <i>MTR_DEFAULT or MTR_FIXED</i>
1669)
1670</pre>
1671<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.
1672<p>
1673
1674<dd> <b>Side Effects</b> The ZDD variable tree is changed.
1675<p>
1676
1677<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_MakeTreeNode">Cudd_MakeTreeNode</a>
1678</code>
1679
1680<dt><pre>
1681int <i></i>
1682<a name="Cudd_MinHammingDist"><b>Cudd_MinHammingDist</b></a>(
1683  DdManager * <b>dd</b>, <i>DD manager</i>
1684  DdNode * <b>f</b>, <i>function to examine</i>
1685  int * <b>minterm</b>, <i>reference minterm</i>
1686  int  <b>upperBound</b> <i>distance above which an approximate answer is OK</i>
1687)
1688</pre>
1689<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.
1690<p>
1691
1692<dd> <b>Side Effects</b> None
1693<p>
1694
1695<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_addHamming">Cudd_addHamming</a>
1696<a href="cuddAllDet.html#Cudd_bddClosestCube">Cudd_bddClosestCube</a>
1697</code>
1698
1699<dt><pre>
1700DdApaNumber <i></i>
1701<a name="Cudd_NewApaNumber"><b>Cudd_NewApaNumber</b></a>(
1702  int  <b>digits</b> <i></i>
1703)
1704</pre>
1705<dd> Allocates memory for an arbitrary precision integer. Returns a pointer to the allocated memory if successful; NULL otherwise.
1706<p>
1707
1708<dd> <b>Side Effects</b> None
1709<p>
1710
1711<dt><pre>
1712int <i></i>
1713<a name="Cudd_NextCube"><b>Cudd_NextCube</b></a>(
1714  DdGen * <b>gen</b>, <i></i>
1715  int ** <b>cube</b>, <i></i>
1716  CUDD_VALUE_TYPE * <b>value</b> <i></i>
1717)
1718</pre>
1719<dd> Generates the next cube of a decision diagram onset, using generator gen. Returns 0 if the enumeration is completed; 1 otherwise.
1720<p>
1721
1722<dd> <b>Side Effects</b> The cube and its value are returned as side effects. The generator is modified.
1723<p>
1724
1725<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_ForeachCube">Cudd_ForeachCube</a>
1726<a href="cuddAllDet.html#Cudd_FirstCube">Cudd_FirstCube</a>
1727<a href="cuddAllDet.html#Cudd_GenFree">Cudd_GenFree</a>
1728<a href="cuddAllDet.html#Cudd_IsGenEmpty">Cudd_IsGenEmpty</a>
1729<a href="cuddAllDet.html#Cudd_NextNode">Cudd_NextNode</a>
1730</code>
1731
1732<dt><pre>
1733int <i></i>
1734<a name="Cudd_NextNode"><b>Cudd_NextNode</b></a>(
1735  DdGen * <b>gen</b>, <i></i>
1736  DdNode ** <b>node</b> <i></i>
1737)
1738</pre>
1739<dd> Finds the node of a decision diagram, using generator gen. Returns 0 if the enumeration is completed; 1 otherwise.
1740<p>
1741
1742<dd> <b>Side Effects</b> The next node is returned as a side effect.
1743<p>
1744
1745<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_ForeachNode">Cudd_ForeachNode</a>
1746<a href="cuddAllDet.html#Cudd_FirstNode">Cudd_FirstNode</a>
1747<a href="cuddAllDet.html#Cudd_GenFree">Cudd_GenFree</a>
1748<a href="cuddAllDet.html#Cudd_IsGenEmpty">Cudd_IsGenEmpty</a>
1749<a href="cuddAllDet.html#Cudd_NextCube">Cudd_NextCube</a>
1750</code>
1751
1752<dt><pre>
1753int <i></i>
1754<a name="Cudd_NextPrime"><b>Cudd_NextPrime</b></a>(
1755  DdGen * <b>gen</b>, <i></i>
1756  int ** <b>cube</b> <i></i>
1757)
1758</pre>
1759<dd> Generates the next cube of a Boolean function, using generator gen. Returns 0 if the enumeration is completed; 1 otherwise.
1760<p>
1761
1762<dd> <b>Side Effects</b> The cube and is returned as side effects. The generator is modified.
1763<p>
1764
1765<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_ForeachPrime">Cudd_ForeachPrime</a>
1766<a href="cuddAllDet.html#Cudd_FirstPrime">Cudd_FirstPrime</a>
1767<a href="cuddAllDet.html#Cudd_GenFree">Cudd_GenFree</a>
1768<a href="cuddAllDet.html#Cudd_IsGenEmpty">Cudd_IsGenEmpty</a>
1769<a href="cuddAllDet.html#Cudd_NextCube">Cudd_NextCube</a>
1770<a href="cuddAllDet.html#Cudd_NextNode">Cudd_NextNode</a>
1771</code>
1772
1773<dt><pre>
1774unsigned int <i></i>
1775<a name="Cudd_NodeReadIndex"><b>Cudd_NodeReadIndex</b></a>(
1776  DdNode * <b>node</b> <i></i>
1777)
1778</pre>
1779<dd> Returns the index of the node. The node pointer can be either regular or complemented.
1780<p>
1781
1782<dd> <b>Side Effects</b> None
1783<p>
1784
1785<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_ReadIndex">Cudd_ReadIndex</a>
1786</code>
1787
1788<dt><pre>
1789 <i></i>
1790<a name="Cudd_NotCond"><b>Cudd_NotCond</b></a>(
1791   <b>node</b>, <i></i>
1792   <b>c</b> <i></i>
1793)
1794</pre>
1795<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".
1796<p>
1797
1798<dd> <b>Side Effects</b> none
1799<p>
1800
1801<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_Not">Cudd_Not</a>
1802</code>
1803
1804<dt><pre>
1805 <i></i>
1806<a name="Cudd_Not"><b>Cudd_Not</b></a>(
1807   <b>node</b> <i></i>
1808)
1809</pre>
1810<dd> Complements a DD by flipping the complement attribute of the pointer (the least significant bit).
1811<p>
1812
1813<dd> <b>Side Effects</b> none
1814<p>
1815
1816<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_NotCond">Cudd_NotCond</a>
1817</code>
1818
1819<dt><pre>
1820void <i></i>
1821<a name="Cudd_OutOfMem"><b>Cudd_OutOfMem</b></a>(
1822  long  <b>size</b> <i>size of the allocation that failed</i>
1823)
1824</pre>
1825<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.
1826<p>
1827
1828<dd> <b>Side Effects</b> None
1829<p>
1830
1831<dt><pre>
1832DdNode * <i></i>
1833<a name="Cudd_OverApprox"><b>Cudd_OverApprox</b></a>(
1834  DdManager * <b>dd</b>, <i>manager</i>
1835  DdNode * <b>f</b>, <i>function to be superset</i>
1836  int  <b>numVars</b>, <i>number of variables in the support of f</i>
1837  int  <b>threshold</b>, <i>when to stop approximation</i>
1838  int  <b>safe</b>, <i>enforce safe approximation</i>
1839  double  <b>quality</b> <i>minimum improvement for accepted changes</i>
1840)
1841</pre>
1842<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.
1843<p>
1844
1845<dd> <b>Side Effects</b> None
1846<p>
1847
1848<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_SupersetHeavyBranch">Cudd_SupersetHeavyBranch</a>
1849<a href="cuddAllDet.html#Cudd_SupersetShortPaths">Cudd_SupersetShortPaths</a>
1850<a href="cuddAllDet.html#Cudd_ReadSize">Cudd_ReadSize</a>
1851</code>
1852
1853<dt><pre>
1854unsigned int <i></i>
1855<a name="Cudd_Prime"><b>Cudd_Prime</b></a>(
1856  unsigned int  <b>p</b> <i></i>
1857)
1858</pre>
1859<dd> Returns the next prime &gt;= p.
1860<p>
1861
1862<dd> <b>Side Effects</b> None
1863<p>
1864
1865<dt><pre>
1866int <i></i>
1867<a name="Cudd_PrintDebug"><b>Cudd_PrintDebug</b></a>(
1868  DdManager * <b>dd</b>, <i></i>
1869  DdNode * <b>f</b>, <i></i>
1870  int  <b>n</b>, <i></i>
1871  int  <b>pr</b> <i></i>
1872)
1873</pre>
1874<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.
1875<p>
1876
1877<dd> <b>Side Effects</b> None
1878<p>
1879
1880<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_DagSize">Cudd_DagSize</a>
1881<a href="cuddAllDet.html#Cudd_CountLeaves">Cudd_CountLeaves</a>
1882<a href="cuddAllDet.html#Cudd_CountMinterm">Cudd_CountMinterm</a>
1883<a href="cuddAllDet.html#Cudd_PrintMinterm">Cudd_PrintMinterm</a>
1884</code>
1885
1886<dt><pre>
1887int <i></i>
1888<a name="Cudd_PrintInfo"><b>Cudd_PrintInfo</b></a>(
1889  DdManager * <b>dd</b>, <i></i>
1890  FILE * <b>fp</b> <i></i>
1891)
1892</pre>
1893<dd> Prints out statistics and settings for a CUDD manager. Returns 1 if successful; 0 otherwise.
1894<p>
1895
1896<dd> <b>Side Effects</b> None
1897<p>
1898
1899<dt><pre>
1900int <i></i>
1901<a name="Cudd_PrintLinear"><b>Cudd_PrintLinear</b></a>(
1902  DdManager * <b>table</b> <i></i>
1903)
1904</pre>
1905<dd> Prints the linear transform matrix. Returns 1 in case of success; 0 otherwise.
1906<p>
1907
1908<dd> <b>Side Effects</b> none
1909<p>
1910
1911<dt><pre>
1912int <i></i>
1913<a name="Cudd_PrintMinterm"><b>Cudd_PrintMinterm</b></a>(
1914  DdManager * <b>manager</b>, <i></i>
1915  DdNode * <b>node</b> <i></i>
1916)
1917</pre>
1918<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.
1919<p>
1920
1921<dd> <b>Side Effects</b> None
1922<p>
1923
1924<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_PrintDebug">Cudd_PrintDebug</a>
1925<a href="cuddAllDet.html#Cudd_bddPrintCover">Cudd_bddPrintCover</a>
1926</code>
1927
1928<dt><pre>
1929int <i></i>
1930<a name="Cudd_PrintTwoLiteralClauses"><b>Cudd_PrintTwoLiteralClauses</b></a>(
1931  DdManager * <b>dd</b>, <i></i>
1932  DdNode * <b>f</b>, <i></i>
1933  char ** <b>names</b>, <i></i>
1934  FILE * <b>fp</b> <i></i>
1935)
1936</pre>
1937<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.
1938<p>
1939
1940<dd> <b>Side Effects</b> None
1941<p>
1942
1943<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_FindTwoLiteralClauses">Cudd_FindTwoLiteralClauses</a>
1944</code>
1945
1946<dt><pre>
1947void <i></i>
1948<a name="Cudd_PrintVersion"><b>Cudd_PrintVersion</b></a>(
1949  FILE * <b>fp</b> <i></i>
1950)
1951</pre>
1952<dd> Prints the package version number.
1953<p>
1954
1955<dd> <b>Side Effects</b> None
1956<p>
1957
1958<dt><pre>
1959DdNode * <i></i>
1960<a name="Cudd_PrioritySelect"><b>Cudd_PrioritySelect</b></a>(
1961  DdManager * <b>dd</b>, <i>manager</i>
1962  DdNode * <b>R</b>, <i>BDD of the relation</i>
1963  DdNode ** <b>x</b>, <i>array of x variables</i>
1964  DdNode ** <b>y</b>, <i>array of y variables</i>
1965  DdNode ** <b>z</b>, <i>array of z variables (optional: may be NULL)</i>
1966  DdNode * <b>Pi</b>, <i>BDD of the priority function (optional: may be NULL)</i>
1967  int  <b>n</b>, <i>size of x, y, and z</i>
1968  DD_PRFP  <b>Pifunc</b> <i>function used to build Pi if it is NULL</i>
1969)
1970</pre>
1971<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>
1972<p>
1973
1974<dd> <b>Side Effects</b> If called with z == NULL, will create new variables in the manager.
1975<p>
1976
1977<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_Dxygtdxz">Cudd_Dxygtdxz</a>
1978<a href="cuddAllDet.html#Cudd_Dxygtdyz">Cudd_Dxygtdyz</a>
1979<a href="cuddAllDet.html#Cudd_Xgty">Cudd_Xgty</a>
1980<a href="cuddAllDet.html#Cudd_bddAdjPermuteX">Cudd_bddAdjPermuteX</a>
1981<a href="cuddAllDet.html#Cudd_CProjection">Cudd_CProjection</a>
1982</code>
1983
1984<dt><pre>
1985void <i></i>
1986<a name="Cudd_Quit"><b>Cudd_Quit</b></a>(
1987  DdManager * <b>unique</b> <i></i>
1988)
1989</pre>
1990<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.)
1991<p>
1992
1993<dd> <b>Side Effects</b> None
1994<p>
1995
1996<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_Init">Cudd_Init</a>
1997</code>
1998
1999<dt><pre>
2000long <i></i>
2001<a name="Cudd_Random"><b>Cudd_Random</b></a>(
2002   <b></b> <i></i>
2003)
2004</pre>
2005<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.
2006<p>
2007
2008<dd> <b>Side Effects</b> None
2009<p>
2010
2011<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_Srandom">Cudd_Srandom</a>
2012</code>
2013
2014<dt><pre>
2015int <i></i>
2016<a name="Cudd_ReadArcviolation"><b>Cudd_ReadArcviolation</b></a>(
2017  DdManager * <b>dd</b> <i></i>
2018)
2019</pre>
2020<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.
2021<p>
2022
2023<dd> <b>Side Effects</b> None
2024<p>
2025
2026<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_SetArcviolation">Cudd_SetArcviolation</a>
2027</code>
2028
2029<dt><pre>
2030DdNode * <i></i>
2031<a name="Cudd_ReadBackground"><b>Cudd_ReadBackground</b></a>(
2032  DdManager * <b>dd</b> <i></i>
2033)
2034</pre>
2035<dd> Reads the background constant of the manager.
2036<p>
2037
2038<dd> <b>Side Effects</b> None
2039<p>
2040
2041<dt><pre>
2042double <i></i>
2043<a name="Cudd_ReadCacheHits"><b>Cudd_ReadCacheHits</b></a>(
2044  DdManager * <b>dd</b> <i></i>
2045)
2046</pre>
2047<dd> Returns the number of cache hits.
2048<p>
2049
2050<dd> <b>Side Effects</b> None
2051<p>
2052
2053<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_ReadCacheLookUps">Cudd_ReadCacheLookUps</a>
2054</code>
2055
2056<dt><pre>
2057double <i></i>
2058<a name="Cudd_ReadCacheLookUps"><b>Cudd_ReadCacheLookUps</b></a>(
2059  DdManager * <b>dd</b> <i></i>
2060)
2061</pre>
2062<dd> Returns the number of cache look-ups.
2063<p>
2064
2065<dd> <b>Side Effects</b> None
2066<p>
2067
2068<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_ReadCacheHits">Cudd_ReadCacheHits</a>
2069</code>
2070
2071<dt><pre>
2072unsigned int <i></i>
2073<a name="Cudd_ReadCacheSlots"><b>Cudd_ReadCacheSlots</b></a>(
2074  DdManager * <b>dd</b> <i></i>
2075)
2076</pre>
2077<dd> Reads the number of slots in the cache.
2078<p>
2079
2080<dd> <b>Side Effects</b> None
2081<p>
2082
2083<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_ReadCacheUsedSlots">Cudd_ReadCacheUsedSlots</a>
2084</code>
2085
2086<dt><pre>
2087double <i></i>
2088<a name="Cudd_ReadCacheUsedSlots"><b>Cudd_ReadCacheUsedSlots</b></a>(
2089  DdManager * <b>dd</b> <i></i>
2090)
2091</pre>
2092<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.
2093<p>
2094
2095<dd> <b>Side Effects</b> None
2096<p>
2097
2098<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_ReadCacheSlots">Cudd_ReadCacheSlots</a>
2099</code>
2100
2101<dt><pre>
2102unsigned int <i></i>
2103<a name="Cudd_ReadDead"><b>Cudd_ReadDead</b></a>(
2104  DdManager * <b>dd</b> <i></i>
2105)
2106</pre>
2107<dd> Returns the number of dead nodes in the unique table.
2108<p>
2109
2110<dd> <b>Side Effects</b> None
2111<p>
2112
2113<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_ReadKeys">Cudd_ReadKeys</a>
2114</code>
2115
2116<dt><pre>
2117CUDD_VALUE_TYPE <i></i>
2118<a name="Cudd_ReadEpsilon"><b>Cudd_ReadEpsilon</b></a>(
2119  DdManager * <b>dd</b> <i></i>
2120)
2121</pre>
2122<dd> Reads the epsilon parameter of the manager. The epsilon parameter control the comparison between floating point numbers.
2123<p>
2124
2125<dd> <b>Side Effects</b> None
2126<p>
2127
2128<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_SetEpsilon">Cudd_SetEpsilon</a>
2129</code>
2130
2131<dt><pre>
2132Cudd_ErrorType <i></i>
2133<a name="Cudd_ReadErrorCode"><b>Cudd_ReadErrorCode</b></a>(
2134  DdManager * <b>dd</b> <i></i>
2135)
2136</pre>
2137<dd> Returns the code of the last error. The error codes are defined in cudd.h.
2138<p>
2139
2140<dd> <b>Side Effects</b> None
2141<p>
2142
2143<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_ClearErrorCode">Cudd_ClearErrorCode</a>
2144</code>
2145
2146<dt><pre>
2147long <i></i>
2148<a name="Cudd_ReadGarbageCollectionTime"><b>Cudd_ReadGarbageCollectionTime</b></a>(
2149  DdManager * <b>dd</b> <i></i>
2150)
2151</pre>
2152<dd> Returns the number of milliseconds spent doing garbage collection since the manager was initialized.
2153<p>
2154
2155<dd> <b>Side Effects</b> None
2156<p>
2157
2158<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_ReadGarbageCollections">Cudd_ReadGarbageCollections</a>
2159</code>
2160
2161<dt><pre>
2162int <i></i>
2163<a name="Cudd_ReadGarbageCollections"><b>Cudd_ReadGarbageCollections</b></a>(
2164  DdManager * <b>dd</b> <i></i>
2165)
2166</pre>
2167<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.
2168<p>
2169
2170<dd> <b>Side Effects</b> None
2171<p>
2172
2173<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_ReadGarbageCollectionTime">Cudd_ReadGarbageCollectionTime</a>
2174</code>
2175
2176<dt><pre>
2177Cudd_AggregationType <i></i>
2178<a name="Cudd_ReadGroupcheck"><b>Cudd_ReadGroupcheck</b></a>(
2179  DdManager * <b>dd</b> <i></i>
2180)
2181</pre>
2182<dd> Reads the groupcheck parameter of the manager. The groupcheck parameter determines the aggregation criterion in group sifting.
2183<p>
2184
2185<dd> <b>Side Effects</b> None
2186<p>
2187
2188<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_SetGroupcheck">Cudd_SetGroupcheck</a>
2189</code>
2190
2191<dt><pre>
2192 <i></i>
2193<a name="Cudd_ReadIndex"><b>Cudd_ReadIndex</b></a>(
2194   <b>dd</b>, <i></i>
2195   <b>index</b> <i></i>
2196)
2197</pre>
2198<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.
2199<p>
2200
2201<dd> <b>Side Effects</b> none
2202<p>
2203
2204<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_ReadPerm">Cudd_ReadPerm</a>
2205</code>
2206
2207<dt><pre>
2208int <i></i>
2209<a name="Cudd_ReadInvPermZdd"><b>Cudd_ReadInvPermZdd</b></a>(
2210  DdManager * <b>dd</b>, <i></i>
2211  int  <b>i</b> <i></i>
2212)
2213</pre>
2214<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.
2215<p>
2216
2217<dd> <b>Side Effects</b> None
2218<p>
2219
2220<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_ReadPerm">Cudd_ReadPerm</a>
2221<a href="cuddAllDet.html#Cudd_ReadInvPermZdd">Cudd_ReadInvPermZdd</a>
2222</code>
2223
2224<dt><pre>
2225int <i></i>
2226<a name="Cudd_ReadInvPerm"><b>Cudd_ReadInvPerm</b></a>(
2227  DdManager * <b>dd</b>, <i></i>
2228  int  <b>i</b> <i></i>
2229)
2230</pre>
2231<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.
2232<p>
2233
2234<dd> <b>Side Effects</b> None
2235<p>
2236
2237<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_ReadPerm">Cudd_ReadPerm</a>
2238<a href="cuddAllDet.html#Cudd_ReadInvPermZdd">Cudd_ReadInvPermZdd</a>
2239</code>
2240
2241<dt><pre>
2242int <i></i>
2243<a name="Cudd_ReadIthClause"><b>Cudd_ReadIthClause</b></a>(
2244  DdTlcInfo * <b>tlc</b>, <i></i>
2245  int  <b>i</b>, <i></i>
2246  DdHalfWord * <b>var1</b>, <i></i>
2247  DdHalfWord * <b>var2</b>, <i></i>
2248  int * <b>phase1</b>, <i></i>
2249  int * <b>phase2</b> <i></i>
2250)
2251</pre>
2252<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.
2253<p>
2254
2255<dd> <b>Side Effects</b> the four components of a clause are returned as side effects.
2256<p>
2257
2258<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_FindTwoLiteralClauses">Cudd_FindTwoLiteralClauses</a>
2259</code>
2260
2261<dt><pre>
2262unsigned int <i></i>
2263<a name="Cudd_ReadKeys"><b>Cudd_ReadKeys</b></a>(
2264  DdManager * <b>dd</b> <i></i>
2265)
2266</pre>
2267<dd> Returns the total number of nodes currently in the unique table, including the dead nodes.
2268<p>
2269
2270<dd> <b>Side Effects</b> None
2271<p>
2272
2273<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_ReadDead">Cudd_ReadDead</a>
2274</code>
2275
2276<dt><pre>
2277int <i></i>
2278<a name="Cudd_ReadLinear"><b>Cudd_ReadLinear</b></a>(
2279  DdManager * <b>table</b>, <i>CUDD manager</i>
2280  int  <b>x</b>, <i>row index</i>
2281  int  <b>y</b> <i>column index</i>
2282)
2283</pre>
2284<dd> Reads an entry of the linear transform matrix.
2285<p>
2286
2287<dd> <b>Side Effects</b> none
2288<p>
2289
2290<dt><pre>
2291DdNode * <i></i>
2292<a name="Cudd_ReadLogicZero"><b>Cudd_ReadLogicZero</b></a>(
2293  DdManager * <b>dd</b> <i></i>
2294)
2295</pre>
2296<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.
2297<p>
2298
2299<dd> <b>Side Effects</b> None
2300<p>
2301
2302<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_ReadOne">Cudd_ReadOne</a>
2303<a href="cuddAllDet.html#Cudd_ReadZero">Cudd_ReadZero</a>
2304</code>
2305
2306<dt><pre>
2307unsigned int <i></i>
2308<a name="Cudd_ReadLooseUpTo"><b>Cudd_ReadLooseUpTo</b></a>(
2309  DdManager * <b>dd</b> <i></i>
2310)
2311</pre>
2312<dd> Reads the looseUpTo parameter of the manager.
2313<p>
2314
2315<dd> <b>Side Effects</b> None
2316<p>
2317
2318<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_SetLooseUpTo">Cudd_SetLooseUpTo</a>
2319<a href="cuddAllDet.html#Cudd_ReadMinHit">Cudd_ReadMinHit</a>
2320<a href="cuddAllDet.html#Cudd_ReadMinDead">Cudd_ReadMinDead</a>
2321</code>
2322
2323<dt><pre>
2324unsigned int <i></i>
2325<a name="Cudd_ReadMaxCacheHard"><b>Cudd_ReadMaxCacheHard</b></a>(
2326  DdManager * <b>dd</b> <i></i>
2327)
2328</pre>
2329<dd> Reads the maxCacheHard parameter of the manager.
2330<p>
2331
2332<dd> <b>Side Effects</b> None
2333<p>
2334
2335<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_SetMaxCacheHard">Cudd_SetMaxCacheHard</a>
2336<a href="cuddAllDet.html#Cudd_ReadMaxCache">Cudd_ReadMaxCache</a>
2337</code>
2338
2339<dt><pre>
2340unsigned int <i></i>
2341<a name="Cudd_ReadMaxCache"><b>Cudd_ReadMaxCache</b></a>(
2342  DdManager * <b>dd</b> <i></i>
2343)
2344</pre>
2345<dd> Returns the soft limit for the cache size. The soft limit
2346<p>
2347
2348<dd> <b>Side Effects</b> None
2349<p>
2350
2351<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_ReadMaxCache">Cudd_ReadMaxCache</a>
2352</code>
2353
2354<dt><pre>
2355double <i></i>
2356<a name="Cudd_ReadMaxGrowthAlternate"><b>Cudd_ReadMaxGrowthAlternate</b></a>(
2357  DdManager * <b>dd</b> <i></i>
2358)
2359</pre>
2360<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.
2361<p>
2362
2363<dd> <b>Side Effects</b> None
2364<p>
2365
2366<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_ReadMaxGrowth">Cudd_ReadMaxGrowth</a>
2367<a href="cuddAllDet.html#Cudd_SetMaxGrowthAlternate">Cudd_SetMaxGrowthAlternate</a>
2368<a href="cuddAllDet.html#Cudd_SetReorderingCycle">Cudd_SetReorderingCycle</a>
2369<a href="cuddAllDet.html#Cudd_ReadReorderingCycle">Cudd_ReadReorderingCycle</a>
2370</code>
2371
2372<dt><pre>
2373double <i></i>
2374<a name="Cudd_ReadMaxGrowth"><b>Cudd_ReadMaxGrowth</b></a>(
2375  DdManager * <b>dd</b> <i></i>
2376)
2377</pre>
2378<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.
2379<p>
2380
2381<dd> <b>Side Effects</b> None
2382<p>
2383
2384<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_SetMaxGrowth">Cudd_SetMaxGrowth</a>
2385<a href="cuddAllDet.html#Cudd_ReadMaxGrowthAlternate">Cudd_ReadMaxGrowthAlternate</a>
2386</code>
2387
2388<dt><pre>
2389unsigned int <i></i>
2390<a name="Cudd_ReadMaxLive"><b>Cudd_ReadMaxLive</b></a>(
2391  DdManager * <b>dd</b> <i></i>
2392)
2393</pre>
2394<dd> Reads the maximum allowed number of live nodes. When this number is exceeded, the package returns NULL.
2395<p>
2396
2397<dd> <b>Side Effects</b> none
2398<p>
2399
2400<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_SetMaxLive">Cudd_SetMaxLive</a>
2401</code>
2402
2403<dt><pre>
2404unsigned long <i></i>
2405<a name="Cudd_ReadMaxMemory"><b>Cudd_ReadMaxMemory</b></a>(
2406  DdManager * <b>dd</b> <i></i>
2407)
2408</pre>
2409<dd> Reads the maximum allowed memory. When this number is exceeded, the package returns NULL.
2410<p>
2411
2412<dd> <b>Side Effects</b> none
2413<p>
2414
2415<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_SetMaxMemory">Cudd_SetMaxMemory</a>
2416</code>
2417
2418<dt><pre>
2419unsigned long <i></i>
2420<a name="Cudd_ReadMemoryInUse"><b>Cudd_ReadMemoryInUse</b></a>(
2421  DdManager * <b>dd</b> <i></i>
2422)
2423</pre>
2424<dd> Returns the memory in use by the manager measured in bytes.
2425<p>
2426
2427<dd> <b>Side Effects</b> None
2428<p>
2429
2430<dt><pre>
2431unsigned int <i></i>
2432<a name="Cudd_ReadMinDead"><b>Cudd_ReadMinDead</b></a>(
2433  DdManager * <b>dd</b> <i></i>
2434)
2435</pre>
2436<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.
2437<p>
2438
2439<dd> <b>Side Effects</b> None
2440<p>
2441
2442<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_ReadDead">Cudd_ReadDead</a>
2443<a href="cuddAllDet.html#Cudd_ReadLooseUpTo">Cudd_ReadLooseUpTo</a>
2444<a href="cuddAllDet.html#Cudd_SetLooseUpTo">Cudd_SetLooseUpTo</a>
2445</code>
2446
2447<dt><pre>
2448unsigned int <i></i>
2449<a name="Cudd_ReadMinHit"><b>Cudd_ReadMinHit</b></a>(
2450  DdManager * <b>dd</b> <i></i>
2451)
2452</pre>
2453<dd> Reads the hit rate that causes resizinig of the computed table.
2454<p>
2455
2456<dd> <b>Side Effects</b> None
2457<p>
2458
2459<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_SetMinHit">Cudd_SetMinHit</a>
2460</code>
2461
2462<dt><pre>
2463DdNode * <i></i>
2464<a name="Cudd_ReadMinusInfinity"><b>Cudd_ReadMinusInfinity</b></a>(
2465  DdManager * <b>dd</b> <i></i>
2466)
2467</pre>
2468<dd> Reads the minus-infinity constant from the manager.
2469<p>
2470
2471<dd> <b>Side Effects</b> None
2472<p>
2473
2474<dt><pre>
2475unsigned int <i></i>
2476<a name="Cudd_ReadNextReordering"><b>Cudd_ReadNextReordering</b></a>(
2477  DdManager * <b>dd</b> <i></i>
2478)
2479</pre>
2480<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.
2481<p>
2482
2483<dd> <b>Side Effects</b> None
2484<p>
2485
2486<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_SetNextReordering">Cudd_SetNextReordering</a>
2487</code>
2488
2489<dt><pre>
2490long <i></i>
2491<a name="Cudd_ReadNodeCount"><b>Cudd_ReadNodeCount</b></a>(
2492  DdManager * <b>dd</b> <i></i>
2493)
2494</pre>
2495<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.
2496<p>
2497
2498<dd> <b>Side Effects</b> None
2499<p>
2500
2501<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_ReadPeakNodeCount">Cudd_ReadPeakNodeCount</a>
2502<a href="cuddAllDet.html#Cudd_zddReadNodeCount">Cudd_zddReadNodeCount</a>
2503</code>
2504
2505<dt><pre>
2506double <i></i>
2507<a name="Cudd_ReadNodesDropped"><b>Cudd_ReadNodesDropped</b></a>(
2508  DdManager * <b>dd</b> <i></i>
2509)
2510</pre>
2511<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.
2512<p>
2513
2514<dd> <b>Side Effects</b> None
2515<p>
2516
2517<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_ReadNodesFreed">Cudd_ReadNodesFreed</a>
2518</code>
2519
2520<dt><pre>
2521double <i></i>
2522<a name="Cudd_ReadNodesFreed"><b>Cudd_ReadNodesFreed</b></a>(
2523  DdManager * <b>dd</b> <i></i>
2524)
2525</pre>
2526<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.
2527<p>
2528
2529<dd> <b>Side Effects</b> None
2530<p>
2531
2532<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_ReadNodesDropped">Cudd_ReadNodesDropped</a>
2533</code>
2534
2535<dt><pre>
2536int <i></i>
2537<a name="Cudd_ReadNumberXovers"><b>Cudd_ReadNumberXovers</b></a>(
2538  DdManager * <b>dd</b> <i></i>
2539)
2540</pre>
2541<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.
2542<p>
2543
2544<dd> <b>Side Effects</b> None
2545<p>
2546
2547<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_SetNumberXovers">Cudd_SetNumberXovers</a>
2548</code>
2549
2550<dt><pre>
2551DdNode * <i></i>
2552<a name="Cudd_ReadOne"><b>Cudd_ReadOne</b></a>(
2553  DdManager * <b>dd</b> <i></i>
2554)
2555</pre>
2556<dd> Returns the one constant of the manager. The one constant is common to ADDs and BDDs.
2557<p>
2558
2559<dd> <b>Side Effects</b> None
2560<p>
2561
2562<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_ReadZero">Cudd_ReadZero</a>
2563<a href="cuddAllDet.html#Cudd_ReadLogicZero">Cudd_ReadLogicZero</a>
2564<a href="cuddAllDet.html#Cudd_ReadZddOne">Cudd_ReadZddOne</a>
2565</code>
2566
2567<dt><pre>
2568int <i></i>
2569<a name="Cudd_ReadPeakLiveNodeCount"><b>Cudd_ReadPeakLiveNodeCount</b></a>(
2570  DdManager * <b>dd</b> <i></i>
2571)
2572</pre>
2573<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.
2574<p>
2575
2576<dd> <b>Side Effects</b> None
2577<p>
2578
2579<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_ReadNodeCount">Cudd_ReadNodeCount</a>
2580<a href="cuddAllDet.html#Cudd_PrintInfo">Cudd_PrintInfo</a>
2581<a href="cuddAllDet.html#Cudd_ReadPeakNodeCount">Cudd_ReadPeakNodeCount</a>
2582</code>
2583
2584<dt><pre>
2585long <i></i>
2586<a name="Cudd_ReadPeakNodeCount"><b>Cudd_ReadPeakNodeCount</b></a>(
2587  DdManager * <b>dd</b> <i></i>
2588)
2589</pre>
2590<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.
2591<p>
2592
2593<dd> <b>Side Effects</b> None
2594<p>
2595
2596<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_ReadNodeCount">Cudd_ReadNodeCount</a>
2597<a href="cuddAllDet.html#Cudd_PrintInfo">Cudd_PrintInfo</a>
2598</code>
2599
2600<dt><pre>
2601int <i></i>
2602<a name="Cudd_ReadPermZdd"><b>Cudd_ReadPermZdd</b></a>(
2603  DdManager * <b>dd</b>, <i></i>
2604  int  <b>i</b> <i></i>
2605)
2606</pre>
2607<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.
2608<p>
2609
2610<dd> <b>Side Effects</b> None
2611<p>
2612
2613<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_ReadInvPermZdd">Cudd_ReadInvPermZdd</a>
2614<a href="cuddAllDet.html#Cudd_ReadPerm">Cudd_ReadPerm</a>
2615</code>
2616
2617<dt><pre>
2618int <i></i>
2619<a name="Cudd_ReadPerm"><b>Cudd_ReadPerm</b></a>(
2620  DdManager * <b>dd</b>, <i></i>
2621  int  <b>i</b> <i></i>
2622)
2623</pre>
2624<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.
2625<p>
2626
2627<dd> <b>Side Effects</b> None
2628<p>
2629
2630<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_ReadInvPerm">Cudd_ReadInvPerm</a>
2631<a href="cuddAllDet.html#Cudd_ReadPermZdd">Cudd_ReadPermZdd</a>
2632</code>
2633
2634<dt><pre>
2635DdNode * <i></i>
2636<a name="Cudd_ReadPlusInfinity"><b>Cudd_ReadPlusInfinity</b></a>(
2637  DdManager * <b>dd</b> <i></i>
2638)
2639</pre>
2640<dd> Reads the plus-infinity constant from the manager.
2641<p>
2642
2643<dd> <b>Side Effects</b> None
2644<p>
2645
2646<dt><pre>
2647int <i></i>
2648<a name="Cudd_ReadPopulationSize"><b>Cudd_ReadPopulationSize</b></a>(
2649  DdManager * <b>dd</b> <i></i>
2650)
2651</pre>
2652<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.
2653<p>
2654
2655<dd> <b>Side Effects</b> None
2656<p>
2657
2658<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_SetPopulationSize">Cudd_SetPopulationSize</a>
2659</code>
2660
2661<dt><pre>
2662int <i></i>
2663<a name="Cudd_ReadRecomb"><b>Cudd_ReadRecomb</b></a>(
2664  DdManager * <b>dd</b> <i></i>
2665)
2666</pre>
2667<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.
2668<p>
2669
2670<dd> <b>Side Effects</b> None
2671<p>
2672
2673<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_SetRecomb">Cudd_SetRecomb</a>
2674</code>
2675
2676<dt><pre>
2677double <i></i>
2678<a name="Cudd_ReadRecursiveCalls"><b>Cudd_ReadRecursiveCalls</b></a>(
2679  DdManager * <b>dd</b> <i></i>
2680)
2681</pre>
2682<dd> Returns the number of recursive calls if the package is compiled with DD_COUNT defined.
2683<p>
2684
2685<dd> <b>Side Effects</b> None
2686<p>
2687
2688<dt><pre>
2689int <i></i>
2690<a name="Cudd_ReadReorderingCycle"><b>Cudd_ReadReorderingCycle</b></a>(
2691  DdManager * <b>dd</b> <i></i>
2692)
2693</pre>
2694<dd> Reads the reordCycle parameter of the manager. This parameter determines how often the alternate threshold on maximum growth is used in reordering.
2695<p>
2696
2697<dd> <b>Side Effects</b> None
2698<p>
2699
2700<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_ReadMaxGrowthAlternate">Cudd_ReadMaxGrowthAlternate</a>
2701<a href="cuddAllDet.html#Cudd_SetMaxGrowthAlternate">Cudd_SetMaxGrowthAlternate</a>
2702<a href="cuddAllDet.html#Cudd_SetReorderingCycle">Cudd_SetReorderingCycle</a>
2703</code>
2704
2705<dt><pre>
2706long <i></i>
2707<a name="Cudd_ReadReorderingTime"><b>Cudd_ReadReorderingTime</b></a>(
2708  DdManager * <b>dd</b> <i></i>
2709)
2710</pre>
2711<dd> Returns the number of milliseconds spent reordering variables since the manager was initialized. The time spent in collecting garbage before reordering is included.
2712<p>
2713
2714<dd> <b>Side Effects</b> None
2715<p>
2716
2717<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_ReadReorderings">Cudd_ReadReorderings</a>
2718</code>
2719
2720<dt><pre>
2721int <i></i>
2722<a name="Cudd_ReadReorderings"><b>Cudd_ReadReorderings</b></a>(
2723  DdManager * <b>dd</b> <i></i>
2724)
2725</pre>
2726<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.
2727<p>
2728
2729<dd> <b>Side Effects</b> None
2730<p>
2731
2732<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_ReduceHeap">Cudd_ReduceHeap</a>
2733<a href="cuddAllDet.html#Cudd_ReadReorderingTime">Cudd_ReadReorderingTime</a>
2734</code>
2735
2736<dt><pre>
2737int <i></i>
2738<a name="Cudd_ReadSiftMaxSwap"><b>Cudd_ReadSiftMaxSwap</b></a>(
2739  DdManager * <b>dd</b> <i></i>
2740)
2741</pre>
2742<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.
2743<p>
2744
2745<dd> <b>Side Effects</b> None
2746<p>
2747
2748<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_ReadSiftMaxVar">Cudd_ReadSiftMaxVar</a>
2749<a href="cuddAllDet.html#Cudd_SetSiftMaxSwap">Cudd_SetSiftMaxSwap</a>
2750</code>
2751
2752<dt><pre>
2753int <i></i>
2754<a name="Cudd_ReadSiftMaxVar"><b>Cudd_ReadSiftMaxVar</b></a>(
2755  DdManager * <b>dd</b> <i></i>
2756)
2757</pre>
2758<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.
2759<p>
2760
2761<dd> <b>Side Effects</b> None
2762<p>
2763
2764<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_ReadSiftMaxSwap">Cudd_ReadSiftMaxSwap</a>
2765<a href="cuddAllDet.html#Cudd_SetSiftMaxVar">Cudd_SetSiftMaxVar</a>
2766</code>
2767
2768<dt><pre>
2769int <i></i>
2770<a name="Cudd_ReadSize"><b>Cudd_ReadSize</b></a>(
2771  DdManager * <b>dd</b> <i></i>
2772)
2773</pre>
2774<dd> Returns the number of BDD variables in existance.
2775<p>
2776
2777<dd> <b>Side Effects</b> None
2778<p>
2779
2780<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_ReadZddSize">Cudd_ReadZddSize</a>
2781</code>
2782
2783<dt><pre>
2784unsigned int <i></i>
2785<a name="Cudd_ReadSlots"><b>Cudd_ReadSlots</b></a>(
2786  DdManager * <b>dd</b> <i></i>
2787)
2788</pre>
2789<dd> Returns the total number of slots of the unique table. This number ismainly for diagnostic purposes.
2790<p>
2791
2792<dd> <b>Side Effects</b> None
2793<p>
2794
2795<dt><pre>
2796FILE * <i></i>
2797<a name="Cudd_ReadStderr"><b>Cudd_ReadStderr</b></a>(
2798  DdManager * <b>dd</b> <i></i>
2799)
2800</pre>
2801<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.
2802<p>
2803
2804<dd> <b>Side Effects</b> None
2805<p>
2806
2807<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_SetStderr">Cudd_SetStderr</a>
2808<a href="cuddAllDet.html#Cudd_ReadStdout">Cudd_ReadStdout</a>
2809</code>
2810
2811<dt><pre>
2812FILE * <i></i>
2813<a name="Cudd_ReadStdout"><b>Cudd_ReadStdout</b></a>(
2814  DdManager * <b>dd</b> <i></i>
2815)
2816</pre>
2817<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.
2818<p>
2819
2820<dd> <b>Side Effects</b> None
2821<p>
2822
2823<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_SetStdout">Cudd_SetStdout</a>
2824<a href="cuddAllDet.html#Cudd_ReadStderr">Cudd_ReadStderr</a>
2825</code>
2826
2827<dt><pre>
2828double <i></i>
2829<a name="Cudd_ReadSwapSteps"><b>Cudd_ReadSwapSteps</b></a>(
2830  DdManager * <b>dd</b> <i></i>
2831)
2832</pre>
2833<dd> Reads the number of elementary reordering steps.
2834<p>
2835
2836<dd> <b>Side Effects</b> none
2837<p>
2838
2839<dt><pre>
2840int <i></i>
2841<a name="Cudd_ReadSymmviolation"><b>Cudd_ReadSymmviolation</b></a>(
2842  DdManager * <b>dd</b> <i></i>
2843)
2844</pre>
2845<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.
2846<p>
2847
2848<dd> <b>Side Effects</b> None
2849<p>
2850
2851<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_SetSymmviolation">Cudd_SetSymmviolation</a>
2852</code>
2853
2854<dt><pre>
2855MtrNode * <i></i>
2856<a name="Cudd_ReadTree"><b>Cudd_ReadTree</b></a>(
2857  DdManager * <b>dd</b> <i></i>
2858)
2859</pre>
2860<dd> Returns the variable group tree of the manager.
2861<p>
2862
2863<dd> <b>Side Effects</b> None
2864<p>
2865
2866<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_SetTree">Cudd_SetTree</a>
2867<a href="cuddAllDet.html#Cudd_FreeTree">Cudd_FreeTree</a>
2868<a href="cuddAllDet.html#Cudd_ReadZddTree">Cudd_ReadZddTree</a>
2869</code>
2870
2871<dt><pre>
2872double <i></i>
2873<a name="Cudd_ReadUniqueLinks"><b>Cudd_ReadUniqueLinks</b></a>(
2874  DdManager * <b>dd</b> <i></i>
2875)
2876</pre>
2877<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.
2878<p>
2879
2880<dd> <b>Side Effects</b> None
2881<p>
2882
2883<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_ReadUniqueLookUps">Cudd_ReadUniqueLookUps</a>
2884</code>
2885
2886<dt><pre>
2887double <i></i>
2888<a name="Cudd_ReadUniqueLookUps"><b>Cudd_ReadUniqueLookUps</b></a>(
2889  DdManager * <b>dd</b> <i></i>
2890)
2891</pre>
2892<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.
2893<p>
2894
2895<dd> <b>Side Effects</b> None
2896<p>
2897
2898<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_ReadUniqueLinks">Cudd_ReadUniqueLinks</a>
2899</code>
2900
2901<dt><pre>
2902double <i></i>
2903<a name="Cudd_ReadUsedSlots"><b>Cudd_ReadUsedSlots</b></a>(
2904  DdManager * <b>dd</b> <i></i>
2905)
2906</pre>
2907<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.
2908<p>
2909
2910<dd> <b>Side Effects</b> None
2911<p>
2912
2913<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_ReadSlots">Cudd_ReadSlots</a>
2914</code>
2915
2916<dt><pre>
2917DdNode * <i></i>
2918<a name="Cudd_ReadVars"><b>Cudd_ReadVars</b></a>(
2919  DdManager * <b>dd</b>, <i></i>
2920  int  <b>i</b> <i></i>
2921)
2922</pre>
2923<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.
2924<p>
2925
2926<dd> <b>Side Effects</b> None
2927<p>
2928
2929<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_bddIthVar">Cudd_bddIthVar</a>
2930</code>
2931
2932<dt><pre>
2933DdNode * <i></i>
2934<a name="Cudd_ReadZddOne"><b>Cudd_ReadZddOne</b></a>(
2935  DdManager * <b>dd</b>, <i></i>
2936  int  <b>i</b> <i></i>
2937)
2938</pre>
2939<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>.
2940<p>
2941
2942<dd> <b>Side Effects</b> None
2943<p>
2944
2945<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_ReadOne">Cudd_ReadOne</a>
2946</code>
2947
2948<dt><pre>
2949int <i></i>
2950<a name="Cudd_ReadZddSize"><b>Cudd_ReadZddSize</b></a>(
2951  DdManager * <b>dd</b> <i></i>
2952)
2953</pre>
2954<dd> Returns the number of ZDD variables in existance.
2955<p>
2956
2957<dd> <b>Side Effects</b> None
2958<p>
2959
2960<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_ReadSize">Cudd_ReadSize</a>
2961</code>
2962
2963<dt><pre>
2964MtrNode * <i></i>
2965<a name="Cudd_ReadZddTree"><b>Cudd_ReadZddTree</b></a>(
2966  DdManager * <b>dd</b> <i></i>
2967)
2968</pre>
2969<dd> Returns the variable group tree of the manager.
2970<p>
2971
2972<dd> <b>Side Effects</b> None
2973<p>
2974
2975<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_SetZddTree">Cudd_SetZddTree</a>
2976<a href="cuddAllDet.html#Cudd_FreeZddTree">Cudd_FreeZddTree</a>
2977<a href="cuddAllDet.html#Cudd_ReadTree">Cudd_ReadTree</a>
2978</code>
2979
2980<dt><pre>
2981DdNode * <i></i>
2982<a name="Cudd_ReadZero"><b>Cudd_ReadZero</b></a>(
2983  DdManager * <b>dd</b> <i></i>
2984)
2985</pre>
2986<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.
2987<p>
2988
2989<dd> <b>Side Effects</b> None
2990<p>
2991
2992<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_ReadOne">Cudd_ReadOne</a>
2993<a href="cuddAllDet.html#Cudd_ReadLogicZero">Cudd_ReadLogicZero</a>
2994</code>
2995
2996<dt><pre>
2997void <i></i>
2998<a name="Cudd_RecursiveDerefZdd"><b>Cudd_RecursiveDerefZdd</b></a>(
2999  DdManager * <b>table</b>, <i></i>
3000  DdNode * <b>n</b> <i></i>
3001)
3002</pre>
3003<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.
3004<p>
3005
3006<dd> <b>Side Effects</b> None
3007<p>
3008
3009<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_Deref">Cudd_Deref</a>
3010<a href="cuddAllDet.html#Cudd_Ref">Cudd_Ref</a>
3011<a href="cuddAllDet.html#Cudd_RecursiveDeref">Cudd_RecursiveDeref</a>
3012</code>
3013
3014<dt><pre>
3015void <i></i>
3016<a name="Cudd_RecursiveDeref"><b>Cudd_RecursiveDeref</b></a>(
3017  DdManager * <b>table</b>, <i></i>
3018  DdNode * <b>n</b> <i></i>
3019)
3020</pre>
3021<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.
3022<p>
3023
3024<dd> <b>Side Effects</b> None
3025<p>
3026
3027<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_Deref">Cudd_Deref</a>
3028<a href="cuddAllDet.html#Cudd_Ref">Cudd_Ref</a>
3029<a href="cuddAllDet.html#Cudd_RecursiveDerefZdd">Cudd_RecursiveDerefZdd</a>
3030</code>
3031
3032<dt><pre>
3033int <i></i>
3034<a name="Cudd_ReduceHeap"><b>Cudd_ReduceHeap</b></a>(
3035  DdManager * <b>table</b>, <i>DD manager</i>
3036  Cudd_ReorderingType  <b>heuristic</b>, <i>method used for reordering</i>
3037  int  <b>minsize</b> <i>bound below which no reordering occurs</i>
3038)
3039</pre>
3040<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.
3041<p>
3042
3043<dd> <b>Side Effects</b> Changes the variable order for all diagrams and clears the cache.
3044<p>
3045
3046<dt><pre>
3047void <i></i>
3048<a name="Cudd_Ref"><b>Cudd_Ref</b></a>(
3049  DdNode * <b>n</b> <i></i>
3050)
3051</pre>
3052<dd> Increases the reference count of a node, if it is not saturated.
3053<p>
3054
3055<dd> <b>Side Effects</b> None
3056<p>
3057
3058<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_RecursiveDeref">Cudd_RecursiveDeref</a>
3059<a href="cuddAllDet.html#Cudd_Deref">Cudd_Deref</a>
3060</code>
3061
3062<dt><pre>
3063 <i></i>
3064<a name="Cudd_Regular"><b>Cudd_Regular</b></a>(
3065   <b>node</b> <i></i>
3066)
3067</pre>
3068<dd> Returns the regular version of a pointer.
3069<p>
3070
3071<dd> <b>Side Effects</b> none
3072<p>
3073
3074<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_Complement">Cudd_Complement</a>
3075<a href="cuddAllDet.html#Cudd_IsComplement">Cudd_IsComplement</a>
3076</code>
3077
3078<dt><pre>
3079DdNode * <i></i>
3080<a name="Cudd_RemapOverApprox"><b>Cudd_RemapOverApprox</b></a>(
3081  DdManager * <b>dd</b>, <i>manager</i>
3082  DdNode * <b>f</b>, <i>function to be superset</i>
3083  int  <b>numVars</b>, <i>number of variables in the support of f</i>
3084  int  <b>threshold</b>, <i>when to stop approximation</i>
3085  double  <b>quality</b> <i>minimum improvement for accepted changes</i>
3086)
3087</pre>
3088<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.
3089<p>
3090
3091<dd> <b>Side Effects</b> None
3092<p>
3093
3094<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_SupersetHeavyBranch">Cudd_SupersetHeavyBranch</a>
3095<a href="cuddAllDet.html#Cudd_SupersetShortPaths">Cudd_SupersetShortPaths</a>
3096<a href="cuddAllDet.html#Cudd_ReadSize">Cudd_ReadSize</a>
3097</code>
3098
3099<dt><pre>
3100DdNode * <i></i>
3101<a name="Cudd_RemapUnderApprox"><b>Cudd_RemapUnderApprox</b></a>(
3102  DdManager * <b>dd</b>, <i>manager</i>
3103  DdNode * <b>f</b>, <i>function to be subset</i>
3104  int  <b>numVars</b>, <i>number of variables in the support of f</i>
3105  int  <b>threshold</b>, <i>when to stop approximation</i>
3106  double  <b>quality</b> <i>minimum improvement for accepted changes</i>
3107)
3108</pre>
3109<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.
3110<p>
3111
3112<dd> <b>Side Effects</b> None
3113<p>
3114
3115<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_SubsetShortPaths">Cudd_SubsetShortPaths</a>
3116<a href="cuddAllDet.html#Cudd_SubsetHeavyBranch">Cudd_SubsetHeavyBranch</a>
3117<a href="cuddAllDet.html#Cudd_UnderApprox">Cudd_UnderApprox</a>
3118<a href="cuddAllDet.html#Cudd_ReadSize">Cudd_ReadSize</a>
3119</code>
3120
3121<dt><pre>
3122int <i></i>
3123<a name="Cudd_RemoveHook"><b>Cudd_RemoveHook</b></a>(
3124  DdManager * <b>dd</b>, <i></i>
3125  DD_HFP  <b>f</b>, <i></i>
3126  Cudd_HookType  <b>where</b> <i></i>
3127)
3128</pre>
3129<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.
3130<p>
3131
3132<dd> <b>Side Effects</b> None
3133<p>
3134
3135<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_AddHook">Cudd_AddHook</a>
3136</code>
3137
3138<dt><pre>
3139int <i></i>
3140<a name="Cudd_ReorderingReporting"><b>Cudd_ReorderingReporting</b></a>(
3141  DdManager * <b>dd</b> <i></i>
3142)
3143</pre>
3144<dd> Returns 1 if reporting of reordering stats is enabled; 0 otherwise.
3145<p>
3146
3147<dd> <b>Side Effects</b> none
3148<p>
3149
3150<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_EnableReorderingReporting">Cudd_EnableReorderingReporting</a>
3151<a href="cuddAllDet.html#Cudd_DisableReorderingReporting">Cudd_DisableReorderingReporting</a>
3152</code>
3153
3154<dt><pre>
3155int <i></i>
3156<a name="Cudd_ReorderingStatusZdd"><b>Cudd_ReorderingStatusZdd</b></a>(
3157  DdManager * <b>unique</b>, <i></i>
3158  Cudd_ReorderingType * <b>method</b> <i></i>
3159)
3160</pre>
3161<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.
3162<p>
3163
3164<dd> <b>Side Effects</b> Parameter method is set to the ZDD reordering method currently selected.
3165<p>
3166
3167<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_AutodynEnableZdd">Cudd_AutodynEnableZdd</a>
3168<a href="cuddAllDet.html#Cudd_AutodynDisableZdd">Cudd_AutodynDisableZdd</a>
3169<a href="cuddAllDet.html#Cudd_ReorderingStatus">Cudd_ReorderingStatus</a>
3170</code>
3171
3172<dt><pre>
3173int <i></i>
3174<a name="Cudd_ReorderingStatus"><b>Cudd_ReorderingStatus</b></a>(
3175  DdManager * <b>unique</b>, <i></i>
3176  Cudd_ReorderingType * <b>method</b> <i></i>
3177)
3178</pre>
3179<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.
3180<p>
3181
3182<dd> <b>Side Effects</b> Parameter method is set to the reordering method currently selected.
3183<p>
3184
3185<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_AutodynEnable">Cudd_AutodynEnable</a>
3186<a href="cuddAllDet.html#Cudd_AutodynDisable">Cudd_AutodynDisable</a>
3187<a href="cuddAllDet.html#Cudd_ReorderingStatusZdd">Cudd_ReorderingStatusZdd</a>
3188</code>
3189
3190<dt><pre>
3191void <i></i>
3192<a name="Cudd_SetArcviolation"><b>Cudd_SetArcviolation</b></a>(
3193  DdManager * <b>dd</b>, <i></i>
3194  int  <b>arcviolation</b> <i></i>
3195)
3196</pre>
3197<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.
3198<p>
3199
3200<dd> <b>Side Effects</b> None
3201<p>
3202
3203<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_ReadArcviolation">Cudd_ReadArcviolation</a>
3204</code>
3205
3206<dt><pre>
3207void <i></i>
3208<a name="Cudd_SetBackground"><b>Cudd_SetBackground</b></a>(
3209  DdManager * <b>dd</b>, <i></i>
3210  DdNode * <b>bck</b> <i></i>
3211)
3212</pre>
3213<dd> Sets the background constant of the manager. It assumes that the DdNode pointer bck is already referenced.
3214<p>
3215
3216<dd> <b>Side Effects</b> None
3217<p>
3218
3219<dt><pre>
3220void <i></i>
3221<a name="Cudd_SetEpsilon"><b>Cudd_SetEpsilon</b></a>(
3222  DdManager * <b>dd</b>, <i></i>
3223  CUDD_VALUE_TYPE  <b>ep</b> <i></i>
3224)
3225</pre>
3226<dd> Sets the epsilon parameter of the manager to ep. The epsilon parameter control the comparison between floating point numbers.
3227<p>
3228
3229<dd> <b>Side Effects</b> None
3230<p>
3231
3232<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_ReadEpsilon">Cudd_ReadEpsilon</a>
3233</code>
3234
3235<dt><pre>
3236void <i></i>
3237<a name="Cudd_SetGroupcheck"><b>Cudd_SetGroupcheck</b></a>(
3238  DdManager * <b>dd</b>, <i></i>
3239  Cudd_AggregationType  <b>gc</b> <i></i>
3240)
3241</pre>
3242<dd> Sets the parameter groupcheck of the manager to gc. The groupcheck parameter determines the aggregation criterion in group sifting.
3243<p>
3244
3245<dd> <b>Side Effects</b> None
3246<p>
3247
3248<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_ReadGroupCheck">Cudd_ReadGroupCheck</a>
3249</code>
3250
3251<dt><pre>
3252void <i></i>
3253<a name="Cudd_SetLooseUpTo"><b>Cudd_SetLooseUpTo</b></a>(
3254  DdManager * <b>dd</b>, <i></i>
3255  unsigned int  <b>lut</b> <i></i>
3256)
3257</pre>
3258<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.
3259<p>
3260
3261<dd> <b>Side Effects</b> None
3262<p>
3263
3264<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_ReadLooseUpTo">Cudd_ReadLooseUpTo</a>
3265<a href="cuddAllDet.html#Cudd_SetMinHit">Cudd_SetMinHit</a>
3266</code>
3267
3268<dt><pre>
3269void <i></i>
3270<a name="Cudd_SetMaxCacheHard"><b>Cudd_SetMaxCacheHard</b></a>(
3271  DdManager * <b>dd</b>, <i></i>
3272  unsigned int  <b>mc</b> <i></i>
3273)
3274</pre>
3275<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.
3276<p>
3277
3278<dd> <b>Side Effects</b> None
3279<p>
3280
3281<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_ReadMaxCacheHard">Cudd_ReadMaxCacheHard</a>
3282<a href="cuddAllDet.html#Cudd_SetMaxCache">Cudd_SetMaxCache</a>
3283</code>
3284
3285<dt><pre>
3286void <i></i>
3287<a name="Cudd_SetMaxGrowthAlternate"><b>Cudd_SetMaxGrowthAlternate</b></a>(
3288  DdManager * <b>dd</b>, <i></i>
3289  double  <b>mg</b> <i></i>
3290)
3291</pre>
3292<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.
3293<p>
3294
3295<dd> <b>Side Effects</b> None
3296<p>
3297
3298<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_ReadMaxGrowthAlternate">Cudd_ReadMaxGrowthAlternate</a>
3299<a href="cuddAllDet.html#Cudd_SetMaxGrowth">Cudd_SetMaxGrowth</a>
3300<a href="cuddAllDet.html#Cudd_SetReorderingCycle">Cudd_SetReorderingCycle</a>
3301<a href="cuddAllDet.html#Cudd_ReadReorderingCycle">Cudd_ReadReorderingCycle</a>
3302</code>
3303
3304<dt><pre>
3305void <i></i>
3306<a name="Cudd_SetMaxGrowth"><b>Cudd_SetMaxGrowth</b></a>(
3307  DdManager * <b>dd</b>, <i></i>
3308  double  <b>mg</b> <i></i>
3309)
3310</pre>
3311<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.
3312<p>
3313
3314<dd> <b>Side Effects</b> None
3315<p>
3316
3317<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_ReadMaxGrowth">Cudd_ReadMaxGrowth</a>
3318<a href="cuddAllDet.html#Cudd_SetMaxGrowthAlternate">Cudd_SetMaxGrowthAlternate</a>
3319</code>
3320
3321<dt><pre>
3322void <i></i>
3323<a name="Cudd_SetMaxLive"><b>Cudd_SetMaxLive</b></a>(
3324  DdManager * <b>dd</b>, <i></i>
3325  unsigned int  <b>maxLive</b> <i></i>
3326)
3327</pre>
3328<dd> Sets the maximum allowed number of live nodes. When this number is exceeded, the package returns NULL.
3329<p>
3330
3331<dd> <b>Side Effects</b> none
3332<p>
3333
3334<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_ReadMaxLive">Cudd_ReadMaxLive</a>
3335</code>
3336
3337<dt><pre>
3338void <i></i>
3339<a name="Cudd_SetMaxMemory"><b>Cudd_SetMaxMemory</b></a>(
3340  DdManager * <b>dd</b>, <i></i>
3341  unsigned long  <b>maxMemory</b> <i></i>
3342)
3343</pre>
3344<dd> Sets the maximum allowed memory. When this number is exceeded, the package returns NULL.
3345<p>
3346
3347<dd> <b>Side Effects</b> none
3348<p>
3349
3350<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_ReadMaxMemory">Cudd_ReadMaxMemory</a>
3351</code>
3352
3353<dt><pre>
3354void <i></i>
3355<a name="Cudd_SetMinHit"><b>Cudd_SetMinHit</b></a>(
3356  DdManager * <b>dd</b>, <i></i>
3357  unsigned int  <b>hr</b> <i></i>
3358)
3359</pre>
3360<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.
3361<p>
3362
3363<dd> <b>Side Effects</b> None
3364<p>
3365
3366<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_ReadMinHit">Cudd_ReadMinHit</a>
3367</code>
3368
3369<dt><pre>
3370void <i></i>
3371<a name="Cudd_SetNextReordering"><b>Cudd_SetNextReordering</b></a>(
3372  DdManager * <b>dd</b>, <i></i>
3373  unsigned int  <b>next</b> <i></i>
3374)
3375</pre>
3376<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.
3377<p>
3378
3379<dd> <b>Side Effects</b> None
3380<p>
3381
3382<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_ReadNextReordering">Cudd_ReadNextReordering</a>
3383</code>
3384
3385<dt><pre>
3386void <i></i>
3387<a name="Cudd_SetNumberXovers"><b>Cudd_SetNumberXovers</b></a>(
3388  DdManager * <b>dd</b>, <i></i>
3389  int  <b>numberXovers</b> <i></i>
3390)
3391</pre>
3392<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.
3393<p>
3394
3395<dd> <b>Side Effects</b> None
3396<p>
3397
3398<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_ReadNumberXovers">Cudd_ReadNumberXovers</a>
3399</code>
3400
3401<dt><pre>
3402void <i></i>
3403<a name="Cudd_SetPopulationSize"><b>Cudd_SetPopulationSize</b></a>(
3404  DdManager * <b>dd</b>, <i></i>
3405  int  <b>populationSize</b> <i></i>
3406)
3407</pre>
3408<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.
3409<p>
3410
3411<dd> <b>Side Effects</b> Changes the manager.
3412<p>
3413
3414<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_ReadPopulationSize">Cudd_ReadPopulationSize</a>
3415</code>
3416
3417<dt><pre>
3418void <i></i>
3419<a name="Cudd_SetRecomb"><b>Cudd_SetRecomb</b></a>(
3420  DdManager * <b>dd</b>, <i></i>
3421  int  <b>recomb</b> <i></i>
3422)
3423</pre>
3424<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.
3425<p>
3426
3427<dd> <b>Side Effects</b> Changes the manager.
3428<p>
3429
3430<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_ReadRecomb">Cudd_ReadRecomb</a>
3431</code>
3432
3433<dt><pre>
3434void <i></i>
3435<a name="Cudd_SetReorderingCycle"><b>Cudd_SetReorderingCycle</b></a>(
3436  DdManager * <b>dd</b>, <i></i>
3437  int  <b>cycle</b> <i></i>
3438)
3439</pre>
3440<dd> Sets the reordCycle parameter of the manager. This parameter determines how often the alternate threshold on maximum growth is used in reordering.
3441<p>
3442
3443<dd> <b>Side Effects</b> None
3444<p>
3445
3446<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_ReadMaxGrowthAlternate">Cudd_ReadMaxGrowthAlternate</a>
3447<a href="cuddAllDet.html#Cudd_SetMaxGrowthAlternate">Cudd_SetMaxGrowthAlternate</a>
3448<a href="cuddAllDet.html#Cudd_ReadReorderingCycle">Cudd_ReadReorderingCycle</a>
3449</code>
3450
3451<dt><pre>
3452void <i></i>
3453<a name="Cudd_SetSiftMaxSwap"><b>Cudd_SetSiftMaxSwap</b></a>(
3454  DdManager * <b>dd</b>, <i></i>
3455  int  <b>sms</b> <i></i>
3456)
3457</pre>
3458<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.
3459<p>
3460
3461<dd> <b>Side Effects</b> None
3462<p>
3463
3464<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_SetSiftMaxVar">Cudd_SetSiftMaxVar</a>
3465<a href="cuddAllDet.html#Cudd_ReadSiftMaxSwap">Cudd_ReadSiftMaxSwap</a>
3466</code>
3467
3468<dt><pre>
3469void <i></i>
3470<a name="Cudd_SetSiftMaxVar"><b>Cudd_SetSiftMaxVar</b></a>(
3471  DdManager * <b>dd</b>, <i></i>
3472  int  <b>smv</b> <i></i>
3473)
3474</pre>
3475<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.
3476<p>
3477
3478<dd> <b>Side Effects</b> None
3479<p>
3480
3481<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_SetSiftMaxSwap">Cudd_SetSiftMaxSwap</a>
3482<a href="cuddAllDet.html#Cudd_ReadSiftMaxVar">Cudd_ReadSiftMaxVar</a>
3483</code>
3484
3485<dt><pre>
3486void <i></i>
3487<a name="Cudd_SetStderr"><b>Cudd_SetStderr</b></a>(
3488  DdManager * <b>dd</b>, <i></i>
3489  FILE * <b>fp</b> <i></i>
3490)
3491</pre>
3492<dd> Sets the stderr of a manager.
3493<p>
3494
3495<dd> <b>Side Effects</b> None
3496<p>
3497
3498<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_ReadStderr">Cudd_ReadStderr</a>
3499<a href="cuddAllDet.html#Cudd_SetStdout">Cudd_SetStdout</a>
3500</code>
3501
3502<dt><pre>
3503void <i></i>
3504<a name="Cudd_SetStdout"><b>Cudd_SetStdout</b></a>(
3505  DdManager * <b>dd</b>, <i></i>
3506  FILE * <b>fp</b> <i></i>
3507)
3508</pre>
3509<dd> Sets the stdout of a manager.
3510<p>
3511
3512<dd> <b>Side Effects</b> None
3513<p>
3514
3515<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_ReadStdout">Cudd_ReadStdout</a>
3516<a href="cuddAllDet.html#Cudd_SetStderr">Cudd_SetStderr</a>
3517</code>
3518
3519<dt><pre>
3520void <i></i>
3521<a name="Cudd_SetSymmviolation"><b>Cudd_SetSymmviolation</b></a>(
3522  DdManager * <b>dd</b>, <i></i>
3523  int  <b>symmviolation</b> <i></i>
3524)
3525</pre>
3526<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.
3527<p>
3528
3529<dd> <b>Side Effects</b> Changes the manager.
3530<p>
3531
3532<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_ReadSymmviolation">Cudd_ReadSymmviolation</a>
3533</code>
3534
3535<dt><pre>
3536void <i></i>
3537<a name="Cudd_SetTree"><b>Cudd_SetTree</b></a>(
3538  DdManager * <b>dd</b>, <i></i>
3539  MtrNode * <b>tree</b> <i></i>
3540)
3541</pre>
3542<dd> Sets the variable group tree of the manager.
3543<p>
3544
3545<dd> <b>Side Effects</b> None
3546<p>
3547
3548<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_FreeTree">Cudd_FreeTree</a>
3549<a href="cuddAllDet.html#Cudd_ReadTree">Cudd_ReadTree</a>
3550<a href="cuddAllDet.html#Cudd_SetZddTree">Cudd_SetZddTree</a>
3551</code>
3552
3553<dt><pre>
3554int <i></i>
3555<a name="Cudd_SetVarMap"><b>Cudd_SetVarMap</b></a>(
3556  DdManager * <b>manager</b>, <i>DD manager</i>
3557  DdNode ** <b>x</b>, <i>first array of variables</i>
3558  DdNode ** <b>y</b>, <i>second array of variables</i>
3559  int  <b>n</b> <i>length of both arrays</i>
3560)
3561</pre>
3562<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.
3563<p>
3564
3565<dd> <b>Side Effects</b> Modifies the manager. May clear the cache.
3566<p>
3567
3568<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_bddVarMap">Cudd_bddVarMap</a>
3569<a href="cuddAllDet.html#Cudd_bddPermute">Cudd_bddPermute</a>
3570<a href="cuddAllDet.html#Cudd_bddSwapVariables">Cudd_bddSwapVariables</a>
3571</code>
3572
3573<dt><pre>
3574void <i></i>
3575<a name="Cudd_SetZddTree"><b>Cudd_SetZddTree</b></a>(
3576  DdManager * <b>dd</b>, <i></i>
3577  MtrNode * <b>tree</b> <i></i>
3578)
3579</pre>
3580<dd> Sets the ZDD variable group tree of the manager.
3581<p>
3582
3583<dd> <b>Side Effects</b> None
3584<p>
3585
3586<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_FreeZddTree">Cudd_FreeZddTree</a>
3587<a href="cuddAllDet.html#Cudd_ReadZddTree">Cudd_ReadZddTree</a>
3588<a href="cuddAllDet.html#Cudd_SetTree">Cudd_SetTree</a>
3589</code>
3590
3591<dt><pre>
3592int <i></i>
3593<a name="Cudd_SharingSize"><b>Cudd_SharingSize</b></a>(
3594  DdNode ** <b>nodeArray</b>, <i></i>
3595  int  <b>n</b> <i></i>
3596)
3597</pre>
3598<dd> Counts the number of nodes in an array of DDs. Shared nodes are counted only once. Returns the total number of nodes.
3599<p>
3600
3601<dd> <b>Side Effects</b> None
3602<p>
3603
3604<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_DagSize">Cudd_DagSize</a>
3605</code>
3606
3607<dt><pre>
3608int <i></i>
3609<a name="Cudd_ShortestLength"><b>Cudd_ShortestLength</b></a>(
3610  DdManager * <b>manager</b>, <i></i>
3611  DdNode * <b>f</b>, <i></i>
3612  int * <b>weight</b> <i></i>
3613)
3614</pre>
3615<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.
3616<p>
3617
3618<dd> <b>Side Effects</b> None
3619<p>
3620
3621<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_ShortestPath">Cudd_ShortestPath</a>
3622</code>
3623
3624<dt><pre>
3625DdNode * <i></i>
3626<a name="Cudd_ShortestPath"><b>Cudd_ShortestPath</b></a>(
3627  DdManager * <b>manager</b>, <i></i>
3628  DdNode * <b>f</b>, <i></i>
3629  int * <b>weight</b>, <i></i>
3630  int * <b>support</b>, <i></i>
3631  int * <b>length</b> <i></i>
3632)
3633</pre>
3634<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.
3635<p>
3636
3637<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.
3638<p>
3639
3640<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_ShortestLength">Cudd_ShortestLength</a>
3641<a href="cuddAllDet.html#Cudd_LargestCube">Cudd_LargestCube</a>
3642</code>
3643
3644<dt><pre>
3645int <i></i>
3646<a name="Cudd_ShuffleHeap"><b>Cudd_ShuffleHeap</b></a>(
3647  DdManager * <b>table</b>, <i>DD manager</i>
3648  int * <b>permutation</b> <i>required variable permutation</i>
3649)
3650</pre>
3651<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.
3652<p>
3653
3654<dd> <b>Side Effects</b> Changes the variable order for all diagrams and clears the cache.
3655<p>
3656
3657<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_ReduceHeap">Cudd_ReduceHeap</a>
3658</code>
3659
3660<dt><pre>
3661DdNode * <i></i>
3662<a name="Cudd_SolveEqn"><b>Cudd_SolveEqn</b></a>(
3663  DdManager * <b>bdd</b>, <i></i>
3664  DdNode * <b>F</b>, <i>the left-hand side of the equation</i>
3665  DdNode * <b>Y</b>, <i>the cube of the y variables</i>
3666  DdNode ** <b>G</b>, <i>the array of solutions (return parameter)</i>
3667  int ** <b>yIndex</b>, <i>index of y variables</i>
3668  int  <b>n</b> <i>numbers of unknowns</i>
3669)
3670</pre>
3671<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.
3672<p>
3673
3674<dd> <b>Side Effects</b> The solution is returned in G; the indices of the y variables are returned in yIndex.
3675<p>
3676
3677<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_VerifySol">Cudd_VerifySol</a>
3678</code>
3679
3680<dt><pre>
3681DdNode * <i></i>
3682<a name="Cudd_SplitSet"><b>Cudd_SplitSet</b></a>(
3683  DdManager * <b>manager</b>, <i></i>
3684  DdNode * <b>S</b>, <i></i>
3685  DdNode ** <b>xVars</b>, <i></i>
3686  int  <b>n</b>, <i></i>
3687  double  <b>m</b> <i></i>
3688)
3689</pre>
3690<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.
3691<p>
3692
3693<dd> <b>Side Effects</b> None
3694<p>
3695
3696<dt><pre>
3697void <i></i>
3698<a name="Cudd_Srandom"><b>Cudd_Srandom</b></a>(
3699  long  <b>seed</b> <i></i>
3700)
3701</pre>
3702<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.
3703<p>
3704
3705<dd> <b>Side Effects</b> None
3706<p>
3707
3708<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_Random">Cudd_Random</a>
3709</code>
3710
3711<dt><pre>
3712int <i></i>
3713<a name="Cudd_StdPostReordHook"><b>Cudd_StdPostReordHook</b></a>(
3714  DdManager * <b>dd</b>, <i></i>
3715  const char * <b>str</b>, <i></i>
3716  void * <b>data</b> <i></i>
3717)
3718</pre>
3719<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.
3720<p>
3721
3722<dd> <b>Side Effects</b> None
3723<p>
3724
3725<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_StdPreReordHook">Cudd_StdPreReordHook</a>
3726</code>
3727
3728<dt><pre>
3729int <i></i>
3730<a name="Cudd_StdPreReordHook"><b>Cudd_StdPreReordHook</b></a>(
3731  DdManager * <b>dd</b>, <i></i>
3732  const char * <b>str</b>, <i></i>
3733  void * <b>data</b> <i></i>
3734)
3735</pre>
3736<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.
3737<p>
3738
3739<dd> <b>Side Effects</b> None
3740<p>
3741
3742<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_StdPostReordHook">Cudd_StdPostReordHook</a>
3743</code>
3744
3745<dt><pre>
3746DdNode * <i></i>
3747<a name="Cudd_SubsetCompress"><b>Cudd_SubsetCompress</b></a>(
3748  DdManager * <b>dd</b>, <i>manager</i>
3749  DdNode * <b>f</b>, <i>BDD whose subset is sought</i>
3750  int  <b>nvars</b>, <i>number of variables in the support of f</i>
3751  int  <b>threshold</b> <i>maximum number of nodes in the subset</i>
3752)
3753</pre>
3754<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.
3755<p>
3756
3757<dd> <b>Side Effects</b> None
3758<p>
3759
3760<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_SubsetRemap">Cudd_SubsetRemap</a>
3761<a href="cuddAllDet.html#Cudd_SubsetShortPaths">Cudd_SubsetShortPaths</a>
3762<a href="cuddAllDet.html#Cudd_SubsetHeavyBranch">Cudd_SubsetHeavyBranch</a>
3763<a href="cuddAllDet.html#Cudd_bddSqueeze">Cudd_bddSqueeze</a>
3764</code>
3765
3766<dt><pre>
3767DdNode * <i></i>
3768<a name="Cudd_SubsetHeavyBranch"><b>Cudd_SubsetHeavyBranch</b></a>(
3769  DdManager * <b>dd</b>, <i>manager</i>
3770  DdNode * <b>f</b>, <i>function to be subset</i>
3771  int  <b>numVars</b>, <i>number of variables in the support of f</i>
3772  int  <b>threshold</b> <i>maximum number of nodes in the subset</i>
3773)
3774</pre>
3775<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.
3776<p>
3777
3778<dd> <b>Side Effects</b> None
3779<p>
3780
3781<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_SubsetShortPaths">Cudd_SubsetShortPaths</a>
3782<a href="cuddAllDet.html#Cudd_SupersetHeavyBranch">Cudd_SupersetHeavyBranch</a>
3783<a href="cuddAllDet.html#Cudd_ReadSize">Cudd_ReadSize</a>
3784</code>
3785
3786<dt><pre>
3787DdNode * <i></i>
3788<a name="Cudd_SubsetShortPaths"><b>Cudd_SubsetShortPaths</b></a>(
3789  DdManager * <b>dd</b>, <i>manager</i>
3790  DdNode * <b>f</b>, <i>function to be subset</i>
3791  int  <b>numVars</b>, <i>number of variables in the support of f</i>
3792  int  <b>threshold</b>, <i>maximum number of nodes in the subset</i>
3793  int  <b>hardlimit</b> <i>flag: 1 if threshold is a hard limit</i>
3794)
3795</pre>
3796<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.
3797<p>
3798
3799<dd> <b>Side Effects</b> None
3800<p>
3801
3802<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_SupersetShortPaths">Cudd_SupersetShortPaths</a>
3803<a href="cuddAllDet.html#Cudd_SubsetHeavyBranch">Cudd_SubsetHeavyBranch</a>
3804<a href="cuddAllDet.html#Cudd_ReadSize">Cudd_ReadSize</a>
3805</code>
3806
3807<dt><pre>
3808DdNode * <i></i>
3809<a name="Cudd_SubsetWithMaskVars"><b>Cudd_SubsetWithMaskVars</b></a>(
3810  DdManager * <b>dd</b>, <i>manager</i>
3811  DdNode * <b>f</b>, <i>function from which to pick a cube</i>
3812  DdNode ** <b>vars</b>, <i>array of variables</i>
3813  int  <b>nvars</b>, <i>size of <code>vars</code></i>
3814  DdNode ** <b>maskVars</b>, <i>array of variables</i>
3815  int  <b>mvars</b> <i>size of <code>maskVars</code></i>
3816)
3817</pre>
3818<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.
3819<p>
3820
3821<dd> <b>Side Effects</b> None
3822<p>
3823
3824<dt><pre>
3825DdNode * <i></i>
3826<a name="Cudd_SupersetCompress"><b>Cudd_SupersetCompress</b></a>(
3827  DdManager * <b>dd</b>, <i>manager</i>
3828  DdNode * <b>f</b>, <i>BDD whose superset is sought</i>
3829  int  <b>nvars</b>, <i>number of variables in the support of f</i>
3830  int  <b>threshold</b> <i>maximum number of nodes in the superset</i>
3831)
3832</pre>
3833<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.
3834<p>
3835
3836<dd> <b>Side Effects</b> None
3837<p>
3838
3839<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_SubsetCompress">Cudd_SubsetCompress</a>
3840<a href="cuddAllDet.html#Cudd_SupersetRemap">Cudd_SupersetRemap</a>
3841<a href="cuddAllDet.html#Cudd_SupersetShortPaths">Cudd_SupersetShortPaths</a>
3842<a href="cuddAllDet.html#Cudd_SupersetHeavyBranch">Cudd_SupersetHeavyBranch</a>
3843<a href="cuddAllDet.html#Cudd_bddSqueeze">Cudd_bddSqueeze</a>
3844</code>
3845
3846<dt><pre>
3847DdNode * <i></i>
3848<a name="Cudd_SupersetHeavyBranch"><b>Cudd_SupersetHeavyBranch</b></a>(
3849  DdManager * <b>dd</b>, <i>manager</i>
3850  DdNode * <b>f</b>, <i>function to be superset</i>
3851  int  <b>numVars</b>, <i>number of variables in the support of f</i>
3852  int  <b>threshold</b> <i>maximum number of nodes in the superset</i>
3853)
3854</pre>
3855<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.
3856<p>
3857
3858<dd> <b>Side Effects</b> None
3859<p>
3860
3861<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_SubsetHeavyBranch">Cudd_SubsetHeavyBranch</a>
3862<a href="cuddAllDet.html#Cudd_SupersetShortPaths">Cudd_SupersetShortPaths</a>
3863<a href="cuddAllDet.html#Cudd_ReadSize">Cudd_ReadSize</a>
3864</code>
3865
3866<dt><pre>
3867DdNode * <i></i>
3868<a name="Cudd_SupersetShortPaths"><b>Cudd_SupersetShortPaths</b></a>(
3869  DdManager * <b>dd</b>, <i>manager</i>
3870  DdNode * <b>f</b>, <i>function to be superset</i>
3871  int  <b>numVars</b>, <i>number of variables in the support of f</i>
3872  int  <b>threshold</b>, <i>maximum number of nodes in the subset</i>
3873  int  <b>hardlimit</b> <i>flag: 1 if threshold is a hard limit</i>
3874)
3875</pre>
3876<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.
3877<p>
3878
3879<dd> <b>Side Effects</b> None
3880<p>
3881
3882<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_SubsetShortPaths">Cudd_SubsetShortPaths</a>
3883<a href="cuddAllDet.html#Cudd_SupersetHeavyBranch">Cudd_SupersetHeavyBranch</a>
3884<a href="cuddAllDet.html#Cudd_ReadSize">Cudd_ReadSize</a>
3885</code>
3886
3887<dt><pre>
3888int * <i></i>
3889<a name="Cudd_SupportIndex"><b>Cudd_SupportIndex</b></a>(
3890  DdManager * <b>dd</b>, <i>manager</i>
3891  DdNode * <b>f</b> <i>DD whose support is sought</i>
3892)
3893</pre>
3894<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.
3895<p>
3896
3897<dd> <b>Side Effects</b> None
3898<p>
3899
3900<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_Support">Cudd_Support</a>
3901<a href="cuddAllDet.html#Cudd_VectorSupport">Cudd_VectorSupport</a>
3902<a href="cuddAllDet.html#Cudd_ClassifySupport">Cudd_ClassifySupport</a>
3903</code>
3904
3905<dt><pre>
3906int <i></i>
3907<a name="Cudd_SupportSize"><b>Cudd_SupportSize</b></a>(
3908  DdManager * <b>dd</b>, <i>manager</i>
3909  DdNode * <b>f</b> <i>DD whose support size is sought</i>
3910)
3911</pre>
3912<dd> Counts the variables on which a DD depends. Returns the number of the variables if successful; CUDD_OUT_OF_MEM otherwise.
3913<p>
3914
3915<dd> <b>Side Effects</b> None
3916<p>
3917
3918<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_Support">Cudd_Support</a>
3919</code>
3920
3921<dt><pre>
3922DdNode * <i></i>
3923<a name="Cudd_Support"><b>Cudd_Support</b></a>(
3924  DdManager * <b>dd</b>, <i>manager</i>
3925  DdNode * <b>f</b> <i>DD whose support is sought</i>
3926)
3927</pre>
3928<dd> Finds the variables on which a DD depends. Returns a BDD consisting of the product of the variables if successful; NULL otherwise.
3929<p>
3930
3931<dd> <b>Side Effects</b> None
3932<p>
3933
3934<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_VectorSupport">Cudd_VectorSupport</a>
3935<a href="cuddAllDet.html#Cudd_ClassifySupport">Cudd_ClassifySupport</a>
3936</code>
3937
3938<dt><pre>
3939void <i></i>
3940<a name="Cudd_SymmProfile"><b>Cudd_SymmProfile</b></a>(
3941  DdManager * <b>table</b>, <i></i>
3942  int  <b>lower</b>, <i></i>
3943  int  <b>upper</b> <i></i>
3944)
3945</pre>
3946<dd> Prints statistics on symmetric variables.
3947<p>
3948
3949<dd> <b>Side Effects</b> None
3950<p>
3951
3952<dt><pre>
3953void <i></i>
3954<a name="Cudd_TurnOffCountDead"><b>Cudd_TurnOffCountDead</b></a>(
3955  DdManager * <b>dd</b> <i></i>
3956)
3957</pre>
3958<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.
3959<p>
3960
3961<dd> <b>Side Effects</b> Changes the manager.
3962<p>
3963
3964<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_TurnOnCountDead">Cudd_TurnOnCountDead</a>
3965<a href="cuddAllDet.html#Cudd_DeadAreCounted">Cudd_DeadAreCounted</a>
3966</code>
3967
3968<dt><pre>
3969void <i></i>
3970<a name="Cudd_TurnOnCountDead"><b>Cudd_TurnOnCountDead</b></a>(
3971  DdManager * <b>dd</b> <i></i>
3972)
3973</pre>
3974<dd> Causes the dead nodes to be counted towards triggering reordering. This causes more frequent reorderings. By default dead nodes are not counted.
3975<p>
3976
3977<dd> <b>Side Effects</b> Changes the manager.
3978<p>
3979
3980<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_TurnOffCountDead">Cudd_TurnOffCountDead</a>
3981<a href="cuddAllDet.html#Cudd_DeadAreCounted">Cudd_DeadAreCounted</a>
3982</code>
3983
3984<dt><pre>
3985 <i></i>
3986<a name="Cudd_T"><b>Cudd_T</b></a>(
3987   <b>node</b> <i></i>
3988)
3989</pre>
3990<dd> Returns the then child of an internal node. If <code>node</code> is a constant node, the result is unpredictable.
3991<p>
3992
3993<dd> <b>Side Effects</b> none
3994<p>
3995
3996<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_E">Cudd_E</a>
3997<a href="cuddAllDet.html#Cudd_V">Cudd_V</a>
3998</code>
3999
4000<dt><pre>
4001DdNode * <i></i>
4002<a name="Cudd_UnderApprox"><b>Cudd_UnderApprox</b></a>(
4003  DdManager * <b>dd</b>, <i>manager</i>
4004  DdNode * <b>f</b>, <i>function to be subset</i>
4005  int  <b>numVars</b>, <i>number of variables in the support of f</i>
4006  int  <b>threshold</b>, <i>when to stop approximation</i>
4007  int  <b>safe</b>, <i>enforce safe approximation</i>
4008  double  <b>quality</b> <i>minimum improvement for accepted changes</i>
4009)
4010</pre>
4011<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.
4012<p>
4013
4014<dd> <b>Side Effects</b> None
4015<p>
4016
4017<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_SubsetShortPaths">Cudd_SubsetShortPaths</a>
4018<a href="cuddAllDet.html#Cudd_SubsetHeavyBranch">Cudd_SubsetHeavyBranch</a>
4019<a href="cuddAllDet.html#Cudd_ReadSize">Cudd_ReadSize</a>
4020</code>
4021
4022<dt><pre>
4023int * <i></i>
4024<a name="Cudd_VectorSupportIndex"><b>Cudd_VectorSupportIndex</b></a>(
4025  DdManager * <b>dd</b>, <i>manager</i>
4026  DdNode ** <b>F</b>, <i>array of DDs whose support is sought</i>
4027  int  <b>n</b> <i>size of the array</i>
4028)
4029</pre>
4030<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.
4031<p>
4032
4033<dd> <b>Side Effects</b> None
4034<p>
4035
4036<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_SupportIndex">Cudd_SupportIndex</a>
4037<a href="cuddAllDet.html#Cudd_VectorSupport">Cudd_VectorSupport</a>
4038<a href="cuddAllDet.html#Cudd_ClassifySupport">Cudd_ClassifySupport</a>
4039</code>
4040
4041<dt><pre>
4042int <i></i>
4043<a name="Cudd_VectorSupportSize"><b>Cudd_VectorSupportSize</b></a>(
4044  DdManager * <b>dd</b>, <i>manager</i>
4045  DdNode ** <b>F</b>, <i>array of DDs whose support is sought</i>
4046  int  <b>n</b> <i>size of the array</i>
4047)
4048</pre>
4049<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.
4050<p>
4051
4052<dd> <b>Side Effects</b> None
4053<p>
4054
4055<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_VectorSupport">Cudd_VectorSupport</a>
4056<a href="cuddAllDet.html#Cudd_SupportSize">Cudd_SupportSize</a>
4057</code>
4058
4059<dt><pre>
4060DdNode * <i></i>
4061<a name="Cudd_VectorSupport"><b>Cudd_VectorSupport</b></a>(
4062  DdManager * <b>dd</b>, <i>manager</i>
4063  DdNode ** <b>F</b>, <i>array of DDs whose support is sought</i>
4064  int  <b>n</b> <i>size of the array</i>
4065)
4066</pre>
4067<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.
4068<p>
4069
4070<dd> <b>Side Effects</b> None
4071<p>
4072
4073<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_Support">Cudd_Support</a>
4074<a href="cuddAllDet.html#Cudd_ClassifySupport">Cudd_ClassifySupport</a>
4075</code>
4076
4077<dt><pre>
4078DdNode * <i></i>
4079<a name="Cudd_VerifySol"><b>Cudd_VerifySol</b></a>(
4080  DdManager * <b>bdd</b>, <i></i>
4081  DdNode * <b>F</b>, <i>the left-hand side of the equation</i>
4082  DdNode ** <b>G</b>, <i>the array of solutions</i>
4083  int * <b>yIndex</b>, <i>index of y variables</i>
4084  int  <b>n</b> <i>numbers of unknowns</i>
4085)
4086</pre>
4087<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.
4088<p>
4089
4090<dd> <b>Side Effects</b> Frees the memory pointed by yIndex.
4091<p>
4092
4093<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_SolveEqn">Cudd_SolveEqn</a>
4094</code>
4095
4096<dt><pre>
4097 <i></i>
4098<a name="Cudd_V"><b>Cudd_V</b></a>(
4099   <b>node</b> <i></i>
4100)
4101</pre>
4102<dd> Returns the value of a constant node. If <code>node</code> is an internal node, the result is unpredictable.
4103<p>
4104
4105<dd> <b>Side Effects</b> none
4106<p>
4107
4108<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_T">Cudd_T</a>
4109<a href="cuddAllDet.html#Cudd_E">Cudd_E</a>
4110</code>
4111
4112<dt><pre>
4113DdNode * <i></i>
4114<a name="Cudd_Xeqy"><b>Cudd_Xeqy</b></a>(
4115  DdManager * <b>dd</b>, <i>DD manager</i>
4116  int  <b>N</b>, <i>number of x and y variables</i>
4117  DdNode ** <b>x</b>, <i>array of x variables</i>
4118  DdNode ** <b>y</b> <i>array of y variables</i>
4119)
4120</pre>
4121<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].
4122<p>
4123
4124<dd> <b>Side Effects</b> None
4125<p>
4126
4127<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_addXeqy">Cudd_addXeqy</a>
4128</code>
4129
4130<dt><pre>
4131DdNode * <i></i>
4132<a name="Cudd_Xgty"><b>Cudd_Xgty</b></a>(
4133  DdManager * <b>dd</b>, <i>DD manager</i>
4134  int  <b>N</b>, <i>number of x and y variables</i>
4135  DdNode ** <b>z</b>, <i>array of z variables: unused</i>
4136  DdNode ** <b>x</b>, <i>array of x variables</i>
4137  DdNode ** <b>y</b> <i>array of y variables</i>
4138)
4139</pre>
4140<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.
4141<p>
4142
4143<dd> <b>Side Effects</b> None
4144<p>
4145
4146<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_PrioritySelect">Cudd_PrioritySelect</a>
4147<a href="cuddAllDet.html#Cudd_Dxygtdxz">Cudd_Dxygtdxz</a>
4148<a href="cuddAllDet.html#Cudd_Dxygtdyz">Cudd_Dxygtdyz</a>
4149</code>
4150
4151<dt><pre>
4152DdNode * <i></i>
4153<a name="Cudd_addAgreement"><b>Cudd_addAgreement</b></a>(
4154  DdManager * <b>dd</b>, <i></i>
4155  DdNode ** <b>f</b>, <i></i>
4156  DdNode ** <b>g</b> <i></i>
4157)
4158</pre>
4159<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.
4160<p>
4161
4162<dd> <b>Side Effects</b> None
4163<p>
4164
4165<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_addApply">Cudd_addApply</a>
4166</code>
4167
4168<dt><pre>
4169DdNode * <i></i>
4170<a name="Cudd_addApply"><b>Cudd_addApply</b></a>(
4171  DdManager * <b>dd</b>, <i></i>
4172  DD_AOP  <b>op</b>, <i></i>
4173  DdNode * <b>f</b>, <i></i>
4174  DdNode * <b>g</b> <i></i>
4175)
4176</pre>
4177<dd> Applies op to the corresponding discriminants of f and g. Returns a pointer to the result if succssful; NULL otherwise.
4178<p>
4179
4180<dd> <b>Side Effects</b> None
4181<p>
4182
4183<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_addMonadicApply">Cudd_addMonadicApply</a>
4184<a href="cuddAllDet.html#Cudd_addPlus">Cudd_addPlus</a>
4185<a href="cuddAllDet.html#Cudd_addTimes">Cudd_addTimes</a>
4186<a href="cuddAllDet.html#Cudd_addThreshold">Cudd_addThreshold</a>
4187<a href="cuddAllDet.html#Cudd_addSetNZ">Cudd_addSetNZ</a>
4188<a href="cuddAllDet.html#Cudd_addDivide">Cudd_addDivide</a>
4189<a href="cuddAllDet.html#Cudd_addMinus">Cudd_addMinus</a>
4190<a href="cuddAllDet.html#Cudd_addMinimum">Cudd_addMinimum</a>
4191<a href="cuddAllDet.html#Cudd_addMaximum">Cudd_addMaximum</a>
4192<a href="cuddAllDet.html#Cudd_addOneZeroMaximum">Cudd_addOneZeroMaximum</a>
4193<a href="cuddAllDet.html#Cudd_addDiff">Cudd_addDiff</a>
4194<a href="cuddAllDet.html#Cudd_addAgreement">Cudd_addAgreement</a>
4195<a href="cuddAllDet.html#Cudd_addOr">Cudd_addOr</a>
4196<a href="cuddAllDet.html#Cudd_addNand">Cudd_addNand</a>
4197<a href="cuddAllDet.html#Cudd_addNor">Cudd_addNor</a>
4198<a href="cuddAllDet.html#Cudd_addXor">Cudd_addXor</a>
4199<a href="cuddAllDet.html#Cudd_addXnor">Cudd_addXnor</a>
4200</code>
4201
4202<dt><pre>
4203DdNode * <i></i>
4204<a name="Cudd_addBddInterval"><b>Cudd_addBddInterval</b></a>(
4205  DdManager * <b>dd</b>, <i></i>
4206  DdNode * <b>f</b>, <i></i>
4207  CUDD_VALUE_TYPE  <b>lower</b>, <i></i>
4208  CUDD_VALUE_TYPE  <b>upper</b> <i></i>
4209)
4210</pre>
4211<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.
4212<p>
4213
4214<dd> <b>Side Effects</b> None
4215<p>
4216
4217<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_addBddThreshold">Cudd_addBddThreshold</a>
4218<a href="cuddAllDet.html#Cudd_addBddStrictThreshold">Cudd_addBddStrictThreshold</a>
4219<a href="cuddAllDet.html#Cudd_addBddPattern">Cudd_addBddPattern</a>
4220<a href="cuddAllDet.html#Cudd_BddToAdd">Cudd_BddToAdd</a>
4221</code>
4222
4223<dt><pre>
4224DdNode * <i></i>
4225<a name="Cudd_addBddIthBit"><b>Cudd_addBddIthBit</b></a>(
4226  DdManager * <b>dd</b>, <i></i>
4227  DdNode * <b>f</b>, <i></i>
4228  int  <b>bit</b> <i></i>
4229)
4230</pre>
4231<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.
4232<p>
4233
4234<dd> <b>Side Effects</b> None
4235<p>
4236
4237<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_addBddInterval">Cudd_addBddInterval</a>
4238<a href="cuddAllDet.html#Cudd_addBddPattern">Cudd_addBddPattern</a>
4239<a href="cuddAllDet.html#Cudd_BddToAdd">Cudd_BddToAdd</a>
4240</code>
4241
4242<dt><pre>
4243DdNode * <i></i>
4244<a name="Cudd_addBddPattern"><b>Cudd_addBddPattern</b></a>(
4245  DdManager * <b>dd</b>, <i></i>
4246  DdNode * <b>f</b> <i></i>
4247)
4248</pre>
4249<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.
4250<p>
4251
4252<dd> <b>Side Effects</b> None
4253<p>
4254
4255<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_BddToAdd">Cudd_BddToAdd</a>
4256<a href="cuddAllDet.html#Cudd_addBddThreshold">Cudd_addBddThreshold</a>
4257<a href="cuddAllDet.html#Cudd_addBddInterval">Cudd_addBddInterval</a>
4258<a href="cuddAllDet.html#Cudd_addBddStrictThreshold">Cudd_addBddStrictThreshold</a>
4259</code>
4260
4261<dt><pre>
4262DdNode * <i></i>
4263<a name="Cudd_addBddStrictThreshold"><b>Cudd_addBddStrictThreshold</b></a>(
4264  DdManager * <b>dd</b>, <i></i>
4265  DdNode * <b>f</b>, <i></i>
4266  CUDD_VALUE_TYPE  <b>value</b> <i></i>
4267)
4268</pre>
4269<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.
4270<p>
4271
4272<dd> <b>Side Effects</b> None
4273<p>
4274
4275<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_addBddInterval">Cudd_addBddInterval</a>
4276<a href="cuddAllDet.html#Cudd_addBddPattern">Cudd_addBddPattern</a>
4277<a href="cuddAllDet.html#Cudd_BddToAdd">Cudd_BddToAdd</a>
4278<a href="cuddAllDet.html#Cudd_addBddThreshold">Cudd_addBddThreshold</a>
4279</code>
4280
4281<dt><pre>
4282DdNode * <i></i>
4283<a name="Cudd_addBddThreshold"><b>Cudd_addBddThreshold</b></a>(
4284  DdManager * <b>dd</b>, <i></i>
4285  DdNode * <b>f</b>, <i></i>
4286  CUDD_VALUE_TYPE  <b>value</b> <i></i>
4287)
4288</pre>
4289<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.
4290<p>
4291
4292<dd> <b>Side Effects</b> None
4293<p>
4294
4295<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_addBddInterval">Cudd_addBddInterval</a>
4296<a href="cuddAllDet.html#Cudd_addBddPattern">Cudd_addBddPattern</a>
4297<a href="cuddAllDet.html#Cudd_BddToAdd">Cudd_BddToAdd</a>
4298<a href="cuddAllDet.html#Cudd_addBddStrictThreshold">Cudd_addBddStrictThreshold</a>
4299</code>
4300
4301<dt><pre>
4302DdNode * <i></i>
4303<a name="Cudd_addCmpl"><b>Cudd_addCmpl</b></a>(
4304  DdManager * <b>dd</b>, <i></i>
4305  DdNode * <b>f</b> <i></i>
4306)
4307</pre>
4308<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.
4309<p>
4310
4311<dd> <b>Side Effects</b> None
4312<p>
4313
4314<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_addNegate">Cudd_addNegate</a>
4315</code>
4316
4317<dt><pre>
4318DdNode * <i></i>
4319<a name="Cudd_addCompose"><b>Cudd_addCompose</b></a>(
4320  DdManager * <b>dd</b>, <i></i>
4321  DdNode * <b>f</b>, <i></i>
4322  DdNode * <b>g</b>, <i></i>
4323  int  <b>v</b> <i></i>
4324)
4325</pre>
4326<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.
4327<p>
4328
4329<dd> <b>Side Effects</b> None
4330<p>
4331
4332<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_bddCompose">Cudd_bddCompose</a>
4333</code>
4334
4335<dt><pre>
4336DdNode * <i></i>
4337<a name="Cudd_addComputeCube"><b>Cudd_addComputeCube</b></a>(
4338  DdManager * <b>dd</b>, <i></i>
4339  DdNode ** <b>vars</b>, <i></i>
4340  int * <b>phase</b>, <i></i>
4341  int  <b>n</b> <i></i>
4342)
4343</pre>
4344<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.
4345<p>
4346
4347<dd> <b>Side Effects</b> none
4348<p>
4349
4350<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_bddComputeCube">Cudd_bddComputeCube</a>
4351</code>
4352
4353<dt><pre>
4354DdNode * <i></i>
4355<a name="Cudd_addConstrain"><b>Cudd_addConstrain</b></a>(
4356  DdManager * <b>dd</b>, <i></i>
4357  DdNode * <b>f</b>, <i></i>
4358  DdNode * <b>c</b> <i></i>
4359)
4360</pre>
4361<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.
4362<p>
4363
4364<dd> <b>Side Effects</b> None
4365<p>
4366
4367<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_bddConstrain">Cudd_bddConstrain</a>
4368</code>
4369
4370<dt><pre>
4371DdNode * <i></i>
4372<a name="Cudd_addConst"><b>Cudd_addConst</b></a>(
4373  DdManager * <b>dd</b>, <i></i>
4374  CUDD_VALUE_TYPE  <b>c</b> <i></i>
4375)
4376</pre>
4377<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.
4378<p>
4379
4380<dd> <b>Side Effects</b> None
4381<p>
4382
4383<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_addNewVar">Cudd_addNewVar</a>
4384<a href="cuddAllDet.html#Cudd_addIthVar">Cudd_addIthVar</a>
4385</code>
4386
4387<dt><pre>
4388DdNode * <i></i>
4389<a name="Cudd_addDiff"><b>Cudd_addDiff</b></a>(
4390  DdManager * <b>dd</b>, <i></i>
4391  DdNode ** <b>f</b>, <i></i>
4392  DdNode ** <b>g</b> <i></i>
4393)
4394</pre>
4395<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.
4396<p>
4397
4398<dd> <b>Side Effects</b> None
4399<p>
4400
4401<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_addApply">Cudd_addApply</a>
4402</code>
4403
4404<dt><pre>
4405DdNode * <i></i>
4406<a name="Cudd_addDivide"><b>Cudd_addDivide</b></a>(
4407  DdManager * <b>dd</b>, <i></i>
4408  DdNode ** <b>f</b>, <i></i>
4409  DdNode ** <b>g</b> <i></i>
4410)
4411</pre>
4412<dd> Integer and floating point division. Returns NULL if not a terminal case; f / g otherwise.
4413<p>
4414
4415<dd> <b>Side Effects</b> None
4416<p>
4417
4418<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_addApply">Cudd_addApply</a>
4419</code>
4420
4421<dt><pre>
4422DdNode * <i></i>
4423<a name="Cudd_addEvalConst"><b>Cudd_addEvalConst</b></a>(
4424  DdManager * <b>dd</b>, <i></i>
4425  DdNode * <b>f</b>, <i></i>
4426  DdNode * <b>g</b> <i></i>
4427)
4428</pre>
4429<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.
4430<p>
4431
4432<dd> <b>Side Effects</b> None
4433<p>
4434
4435<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_addIteConstant">Cudd_addIteConstant</a>
4436<a href="cuddAllDet.html#Cudd_addLeq">Cudd_addLeq</a>
4437</code>
4438
4439<dt><pre>
4440DdNode * <i></i>
4441<a name="Cudd_addExistAbstract"><b>Cudd_addExistAbstract</b></a>(
4442  DdManager * <b>manager</b>, <i></i>
4443  DdNode * <b>f</b>, <i></i>
4444  DdNode * <b>cube</b> <i></i>
4445)
4446</pre>
4447<dd> Abstracts all the variables in cube from f by summing over all possible values taken by the variables. Returns the abstracted ADD.
4448<p>
4449
4450<dd> <b>Side Effects</b> None
4451<p>
4452
4453<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_addUnivAbstract">Cudd_addUnivAbstract</a>
4454<a href="cuddAllDet.html#Cudd_bddExistAbstract">Cudd_bddExistAbstract</a>
4455<a href="cuddAllDet.html#Cudd_addOrAbstract">Cudd_addOrAbstract</a>
4456</code>
4457
4458<dt><pre>
4459DdNode * <i></i>
4460<a name="Cudd_addFindMax"><b>Cudd_addFindMax</b></a>(
4461  DdManager * <b>dd</b>, <i></i>
4462  DdNode * <b>f</b> <i></i>
4463)
4464</pre>
4465<dd> Returns a pointer to a constant ADD.
4466<p>
4467
4468<dd> <b>Side Effects</b> None
4469<p>
4470
4471<dt><pre>
4472DdNode * <i></i>
4473<a name="Cudd_addFindMin"><b>Cudd_addFindMin</b></a>(
4474  DdManager * <b>dd</b>, <i></i>
4475  DdNode * <b>f</b> <i></i>
4476)
4477</pre>
4478<dd> Returns a pointer to a constant ADD.
4479<p>
4480
4481<dd> <b>Side Effects</b> None
4482<p>
4483
4484<dt><pre>
4485DdNode * <i></i>
4486<a name="Cudd_addGeneralVectorCompose"><b>Cudd_addGeneralVectorCompose</b></a>(
4487  DdManager * <b>dd</b>, <i></i>
4488  DdNode * <b>f</b>, <i></i>
4489  DdNode ** <b>vectorOn</b>, <i></i>
4490  DdNode ** <b>vectorOff</b> <i></i>
4491)
4492</pre>
4493<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.
4494<p>
4495
4496<dd> <b>Side Effects</b> None
4497<p>
4498
4499<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_addVectorCompose">Cudd_addVectorCompose</a>
4500<a href="cuddAllDet.html#Cudd_addNonSimCompose">Cudd_addNonSimCompose</a>
4501<a href="cuddAllDet.html#Cudd_addPermute">Cudd_addPermute</a>
4502<a href="cuddAllDet.html#Cudd_addCompose">Cudd_addCompose</a>
4503<a href="cuddAllDet.html#Cudd_bddVectorCompose">Cudd_bddVectorCompose</a>
4504</code>
4505
4506<dt><pre>
4507DdNode * <i></i>
4508<a name="Cudd_addHamming"><b>Cudd_addHamming</b></a>(
4509  DdManager * <b>dd</b>, <i></i>
4510  DdNode ** <b>xVars</b>, <i></i>
4511  DdNode ** <b>yVars</b>, <i></i>
4512  int  <b>nVars</b> <i></i>
4513)
4514</pre>
4515<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.
4516<p>
4517
4518<dd> <b>Side Effects</b> None
4519<p>
4520
4521<dt><pre>
4522int <i></i>
4523<a name="Cudd_addHarwell"><b>Cudd_addHarwell</b></a>(
4524  FILE * <b>fp</b>, <i>pointer to the input file</i>
4525  DdManager * <b>dd</b>, <i>DD manager</i>
4526  DdNode ** <b>E</b>, <i>characteristic function of the graph</i>
4527  DdNode *** <b>x</b>, <i>array of row variables</i>
4528  DdNode *** <b>y</b>, <i>array of column variables</i>
4529  DdNode *** <b>xn</b>, <i>array of complemented row variables</i>
4530  DdNode *** <b>yn_</b>, <i>array of complemented column variables</i>
4531  int * <b>nx</b>, <i>number or row variables</i>
4532  int * <b>ny</b>, <i>number or column variables</i>
4533  int * <b>m</b>, <i>number of rows</i>
4534  int * <b>n</b>, <i>number of columns</i>
4535  int  <b>bx</b>, <i>first index of row variables</i>
4536  int  <b>sx</b>, <i>step of row variables</i>
4537  int  <b>by</b>, <i>first index of column variables</i>
4538  int  <b>sy</b>, <i>step of column variables</i>
4539  int  <b>pr</b> <i>verbosity level</i>
4540)
4541</pre>
4542<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.
4543<p>
4544
4545<dd> <b>Side Effects</b> None
4546<p>
4547
4548<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_addRead">Cudd_addRead</a>
4549<a href="cuddAllDet.html#Cudd_bddRead">Cudd_bddRead</a>
4550</code>
4551
4552<dt><pre>
4553DdNode * <i></i>
4554<a name="Cudd_addIteConstant"><b>Cudd_addIteConstant</b></a>(
4555  DdManager * <b>dd</b>, <i></i>
4556  DdNode * <b>f</b>, <i></i>
4557  DdNode * <b>g</b>, <i></i>
4558  DdNode * <b>h</b> <i></i>
4559)
4560</pre>
4561<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.
4562<p>
4563
4564<dd> <b>Side Effects</b> None
4565<p>
4566
4567<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_addIte">Cudd_addIte</a>
4568<a href="cuddAllDet.html#Cudd_addEvalConst">Cudd_addEvalConst</a>
4569<a href="cuddAllDet.html#Cudd_bddIteConstant">Cudd_bddIteConstant</a>
4570</code>
4571
4572<dt><pre>
4573DdNode * <i></i>
4574<a name="Cudd_addIte"><b>Cudd_addIte</b></a>(
4575  DdManager * <b>dd</b>, <i></i>
4576  DdNode * <b>f</b>, <i></i>
4577  DdNode * <b>g</b>, <i></i>
4578  DdNode * <b>h</b> <i></i>
4579)
4580</pre>
4581<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.
4582<p>
4583
4584<dd> <b>Side Effects</b> None
4585<p>
4586
4587<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_bddIte">Cudd_bddIte</a>
4588<a href="cuddAllDet.html#Cudd_addIteConstant">Cudd_addIteConstant</a>
4589<a href="cuddAllDet.html#Cudd_addApply">Cudd_addApply</a>
4590</code>
4591
4592<dt><pre>
4593DdNode * <i></i>
4594<a name="Cudd_addIthBit"><b>Cudd_addIthBit</b></a>(
4595  DdManager * <b>dd</b>, <i></i>
4596  DdNode * <b>f</b>, <i></i>
4597  int  <b>bit</b> <i></i>
4598)
4599</pre>
4600<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.
4601<p>
4602
4603<dd> <b>Side Effects</b> None
4604<p>
4605
4606<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_addBddIthBit">Cudd_addBddIthBit</a>
4607</code>
4608
4609<dt><pre>
4610DdNode * <i></i>
4611<a name="Cudd_addIthVar"><b>Cudd_addIthVar</b></a>(
4612  DdManager * <b>dd</b>, <i></i>
4613  int  <b>i</b> <i></i>
4614)
4615</pre>
4616<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.
4617<p>
4618
4619<dd> <b>Side Effects</b> None
4620<p>
4621
4622<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_addNewVar">Cudd_addNewVar</a>
4623<a href="cuddAllDet.html#Cudd_bddIthVar">Cudd_bddIthVar</a>
4624<a href="cuddAllDet.html#Cudd_addConst">Cudd_addConst</a>
4625<a href="cuddAllDet.html#Cudd_addNewVarAtLevel">Cudd_addNewVarAtLevel</a>
4626</code>
4627
4628<dt><pre>
4629int <i></i>
4630<a name="Cudd_addLeq"><b>Cudd_addLeq</b></a>(
4631  DdManager * <b>dd</b>, <i></i>
4632  DdNode * <b>f</b>, <i></i>
4633  DdNode * <b>g</b> <i></i>
4634)
4635</pre>
4636<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.
4637<p>
4638
4639<dd> <b>Side Effects</b> None
4640<p>
4641
4642<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_addIteConstant">Cudd_addIteConstant</a>
4643<a href="cuddAllDet.html#Cudd_addEvalConst">Cudd_addEvalConst</a>
4644<a href="cuddAllDet.html#Cudd_bddLeq">Cudd_bddLeq</a>
4645</code>
4646
4647<dt><pre>
4648DdNode * <i></i>
4649<a name="Cudd_addLog"><b>Cudd_addLog</b></a>(
4650  DdManager * <b>dd</b>, <i></i>
4651  DdNode * <b>f</b> <i></i>
4652)
4653</pre>
4654<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.
4655<p>
4656
4657<dd> <b>Side Effects</b> None
4658<p>
4659
4660<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_addMonadicApply">Cudd_addMonadicApply</a>
4661</code>
4662
4663<dt><pre>
4664DdNode * <i></i>
4665<a name="Cudd_addMatrixMultiply"><b>Cudd_addMatrixMultiply</b></a>(
4666  DdManager * <b>dd</b>, <i></i>
4667  DdNode * <b>A</b>, <i></i>
4668  DdNode * <b>B</b>, <i></i>
4669  DdNode ** <b>z</b>, <i></i>
4670  int  <b>nz</b> <i></i>
4671)
4672</pre>
4673<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.
4674<p>
4675
4676<dd> <b>Side Effects</b> None
4677<p>
4678
4679<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_addTimesPlus">Cudd_addTimesPlus</a>
4680<a href="cuddAllDet.html#Cudd_addTriangle">Cudd_addTriangle</a>
4681<a href="cuddAllDet.html#Cudd_bddAndAbstract">Cudd_bddAndAbstract</a>
4682</code>
4683
4684<dt><pre>
4685DdNode * <i></i>
4686<a name="Cudd_addMaximum"><b>Cudd_addMaximum</b></a>(
4687  DdManager * <b>dd</b>, <i></i>
4688  DdNode ** <b>f</b>, <i></i>
4689  DdNode ** <b>g</b> <i></i>
4690)
4691</pre>
4692<dd> Integer and floating point max for Cudd_addApply. Returns NULL if not a terminal case; max(f,g) otherwise.
4693<p>
4694
4695<dd> <b>Side Effects</b> None
4696<p>
4697
4698<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_addApply">Cudd_addApply</a>
4699</code>
4700
4701<dt><pre>
4702DdNode * <i></i>
4703<a name="Cudd_addMinimum"><b>Cudd_addMinimum</b></a>(
4704  DdManager * <b>dd</b>, <i></i>
4705  DdNode ** <b>f</b>, <i></i>
4706  DdNode ** <b>g</b> <i></i>
4707)
4708</pre>
4709<dd> Integer and floating point min for Cudd_addApply. Returns NULL if not a terminal case; min(f,g) otherwise.
4710<p>
4711
4712<dd> <b>Side Effects</b> None
4713<p>
4714
4715<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_addApply">Cudd_addApply</a>
4716</code>
4717
4718<dt><pre>
4719DdNode * <i></i>
4720<a name="Cudd_addMinus"><b>Cudd_addMinus</b></a>(
4721  DdManager * <b>dd</b>, <i></i>
4722  DdNode ** <b>f</b>, <i></i>
4723  DdNode ** <b>g</b> <i></i>
4724)
4725</pre>
4726<dd> Integer and floating point subtraction. Returns NULL if not a terminal case; f - g otherwise.
4727<p>
4728
4729<dd> <b>Side Effects</b> None
4730<p>
4731
4732<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_addApply">Cudd_addApply</a>
4733</code>
4734
4735<dt><pre>
4736DdNode * <i></i>
4737<a name="Cudd_addMonadicApply"><b>Cudd_addMonadicApply</b></a>(
4738  DdManager * <b>dd</b>, <i></i>
4739  DD_MAOP  <b>op</b>, <i></i>
4740  DdNode * <b>f</b> <i></i>
4741)
4742</pre>
4743<dd> Applies op to the discriminants of f. Returns a pointer to the result if succssful; NULL otherwise.
4744<p>
4745
4746<dd> <b>Side Effects</b> None
4747<p>
4748
4749<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_addApply">Cudd_addApply</a>
4750<a href="cuddAllDet.html#Cudd_addLog">Cudd_addLog</a>
4751</code>
4752
4753<dt><pre>
4754DdNode * <i></i>
4755<a name="Cudd_addNand"><b>Cudd_addNand</b></a>(
4756  DdManager * <b>dd</b>, <i></i>
4757  DdNode ** <b>f</b>, <i></i>
4758  DdNode ** <b>g</b> <i></i>
4759)
4760</pre>
4761<dd> NAND of two 0-1 ADDs. Returns NULL if not a terminal case; f NAND g otherwise.
4762<p>
4763
4764<dd> <b>Side Effects</b> None
4765<p>
4766
4767<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_addApply">Cudd_addApply</a>
4768</code>
4769
4770<dt><pre>
4771DdNode * <i></i>
4772<a name="Cudd_addNegate"><b>Cudd_addNegate</b></a>(
4773  DdManager * <b>dd</b>, <i></i>
4774  DdNode * <b>f</b> <i></i>
4775)
4776</pre>
4777<dd> Computes the additive inverse of an ADD. Returns a pointer to the result if successful; NULL otherwise.
4778<p>
4779
4780<dd> <b>Side Effects</b> None
4781<p>
4782
4783<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_addCmpl">Cudd_addCmpl</a>
4784</code>
4785
4786<dt><pre>
4787DdNode * <i></i>
4788<a name="Cudd_addNewVarAtLevel"><b>Cudd_addNewVarAtLevel</b></a>(
4789  DdManager * <b>dd</b>, <i></i>
4790  int  <b>level</b> <i></i>
4791)
4792</pre>
4793<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.
4794<p>
4795
4796<dd> <b>Side Effects</b> None
4797<p>
4798
4799<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_addNewVar">Cudd_addNewVar</a>
4800<a href="cuddAllDet.html#Cudd_addIthVar">Cudd_addIthVar</a>
4801<a href="cuddAllDet.html#Cudd_bddNewVarAtLevel">Cudd_bddNewVarAtLevel</a>
4802</code>
4803
4804<dt><pre>
4805DdNode * <i></i>
4806<a name="Cudd_addNewVar"><b>Cudd_addNewVar</b></a>(
4807  DdManager * <b>dd</b> <i></i>
4808)
4809</pre>
4810<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.
4811<p>
4812
4813<dd> <b>Side Effects</b> None
4814<p>
4815
4816<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_bddNewVar">Cudd_bddNewVar</a>
4817<a href="cuddAllDet.html#Cudd_addIthVar">Cudd_addIthVar</a>
4818<a href="cuddAllDet.html#Cudd_addConst">Cudd_addConst</a>
4819<a href="cuddAllDet.html#Cudd_addNewVarAtLevel">Cudd_addNewVarAtLevel</a>
4820</code>
4821
4822<dt><pre>
4823DdNode * <i></i>
4824<a name="Cudd_addNonSimCompose"><b>Cudd_addNonSimCompose</b></a>(
4825  DdManager * <b>dd</b>, <i></i>
4826  DdNode * <b>f</b>, <i></i>
4827  DdNode ** <b>vector</b> <i></i>
4828)
4829</pre>
4830<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.
4831<p>
4832
4833<dd> <b>Side Effects</b> None
4834<p>
4835
4836<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_addVectorCompose">Cudd_addVectorCompose</a>
4837<a href="cuddAllDet.html#Cudd_addPermute">Cudd_addPermute</a>
4838<a href="cuddAllDet.html#Cudd_addCompose">Cudd_addCompose</a>
4839</code>
4840
4841<dt><pre>
4842DdNode * <i></i>
4843<a name="Cudd_addNor"><b>Cudd_addNor</b></a>(
4844  DdManager * <b>dd</b>, <i></i>
4845  DdNode ** <b>f</b>, <i></i>
4846  DdNode ** <b>g</b> <i></i>
4847)
4848</pre>
4849<dd> NOR of two 0-1 ADDs. Returns NULL if not a terminal case; f NOR g otherwise.
4850<p>
4851
4852<dd> <b>Side Effects</b> None
4853<p>
4854
4855<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_addApply">Cudd_addApply</a>
4856</code>
4857
4858<dt><pre>
4859DdNode * <i></i>
4860<a name="Cudd_addOneZeroMaximum"><b>Cudd_addOneZeroMaximum</b></a>(
4861  DdManager * <b>dd</b>, <i></i>
4862  DdNode ** <b>f</b>, <i></i>
4863  DdNode ** <b>g</b> <i></i>
4864)
4865</pre>
4866<dd> Returns 1 if f &gt; g and 0 otherwise. Used in conjunction with Cudd_addApply. Returns NULL if not a terminal case.
4867<p>
4868
4869<dd> <b>Side Effects</b> None
4870<p>
4871
4872<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_addApply">Cudd_addApply</a>
4873</code>
4874
4875<dt><pre>
4876DdNode * <i></i>
4877<a name="Cudd_addOrAbstract"><b>Cudd_addOrAbstract</b></a>(
4878  DdManager * <b>manager</b>, <i></i>
4879  DdNode * <b>f</b>, <i></i>
4880  DdNode * <b>cube</b> <i></i>
4881)
4882</pre>
4883<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.
4884<p>
4885
4886<dd> <b>Side Effects</b> None
4887<p>
4888
4889<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_addUnivAbstract">Cudd_addUnivAbstract</a>
4890<a href="cuddAllDet.html#Cudd_addExistAbstract">Cudd_addExistAbstract</a>
4891</code>
4892
4893<dt><pre>
4894DdNode * <i></i>
4895<a name="Cudd_addOr"><b>Cudd_addOr</b></a>(
4896  DdManager * <b>dd</b>, <i></i>
4897  DdNode ** <b>f</b>, <i></i>
4898  DdNode ** <b>g</b> <i></i>
4899)
4900</pre>
4901<dd> Disjunction of two 0-1 ADDs. Returns NULL if not a terminal case; f OR g otherwise.
4902<p>
4903
4904<dd> <b>Side Effects</b> None
4905<p>
4906
4907<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_addApply">Cudd_addApply</a>
4908</code>
4909
4910<dt><pre>
4911DdNode * <i></i>
4912<a name="Cudd_addOuterSum"><b>Cudd_addOuterSum</b></a>(
4913  DdManager * <b>dd</b>, <i></i>
4914  DdNode * <b>M</b>, <i></i>
4915  DdNode * <b>r</b>, <i></i>
4916  DdNode * <b>c</b> <i></i>
4917)
4918</pre>
4919<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.
4920<p>
4921
4922<dd> <b>Side Effects</b> None
4923<p>
4924
4925<dt><pre>
4926DdNode * <i></i>
4927<a name="Cudd_addPermute"><b>Cudd_addPermute</b></a>(
4928  DdManager * <b>manager</b>, <i></i>
4929  DdNode * <b>node</b>, <i></i>
4930  int * <b>permut</b> <i></i>
4931)
4932</pre>
4933<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.
4934<p>
4935
4936<dd> <b>Side Effects</b> None
4937<p>
4938
4939<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_bddPermute">Cudd_bddPermute</a>
4940<a href="cuddAllDet.html#Cudd_addSwapVariables">Cudd_addSwapVariables</a>
4941</code>
4942
4943<dt><pre>
4944DdNode * <i></i>
4945<a name="Cudd_addPlus"><b>Cudd_addPlus</b></a>(
4946  DdManager * <b>dd</b>, <i></i>
4947  DdNode ** <b>f</b>, <i></i>
4948  DdNode ** <b>g</b> <i></i>
4949)
4950</pre>
4951<dd> Integer and floating point addition. Returns NULL if not a terminal case; f+g otherwise.
4952<p>
4953
4954<dd> <b>Side Effects</b> None
4955<p>
4956
4957<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_addApply">Cudd_addApply</a>
4958</code>
4959
4960<dt><pre>
4961int <i></i>
4962<a name="Cudd_addRead"><b>Cudd_addRead</b></a>(
4963  FILE * <b>fp</b>, <i>input file pointer</i>
4964  DdManager * <b>dd</b>, <i>DD manager</i>
4965  DdNode ** <b>E</b>, <i>characteristic function of the graph</i>
4966  DdNode *** <b>x</b>, <i>array of row variables</i>
4967  DdNode *** <b>y</b>, <i>array of column variables</i>
4968  DdNode *** <b>xn</b>, <i>array of complemented row variables</i>
4969  DdNode *** <b>yn_</b>, <i>array of complemented column variables</i>
4970  int * <b>nx</b>, <i>number or row variables</i>
4971  int * <b>ny</b>, <i>number or column variables</i>
4972  int * <b>m</b>, <i>number of rows</i>
4973  int * <b>n</b>, <i>number of columns</i>
4974  int  <b>bx</b>, <i>first index of row variables</i>
4975  int  <b>sx</b>, <i>step of row variables</i>
4976  int  <b>by</b>, <i>first index of column variables</i>
4977  int  <b>sy</b> <i>step of column variables</i>
4978)
4979</pre>
4980<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.
4981<p>
4982
4983<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.
4984<p>
4985
4986<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_addHarwell">Cudd_addHarwell</a>
4987<a href="cuddAllDet.html#Cudd_bddRead">Cudd_bddRead</a>
4988</code>
4989
4990<dt><pre>
4991DdNode * <i></i>
4992<a name="Cudd_addResidue"><b>Cudd_addResidue</b></a>(
4993  DdManager * <b>dd</b>, <i>manager</i>
4994  int  <b>n</b>, <i>number of bits</i>
4995  int  <b>m</b>, <i>modulus</i>
4996  int  <b>options</b>, <i>options</i>
4997  int  <b>top</b> <i>index of top variable</i>
4998)
4999</pre>
5000<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.
5001<p>
5002
5003<dd> <b>Side Effects</b> None
5004<p>
5005
5006<dt><pre>
5007DdNode * <i></i>
5008<a name="Cudd_addRestrict"><b>Cudd_addRestrict</b></a>(
5009  DdManager * <b>dd</b>, <i></i>
5010  DdNode * <b>f</b>, <i></i>
5011  DdNode * <b>c</b> <i></i>
5012)
5013</pre>
5014<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.
5015<p>
5016
5017<dd> <b>Side Effects</b> None
5018<p>
5019
5020<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_addConstrain">Cudd_addConstrain</a>
5021<a href="cuddAllDet.html#Cudd_bddRestrict">Cudd_bddRestrict</a>
5022</code>
5023
5024<dt><pre>
5025DdNode * <i></i>
5026<a name="Cudd_addRoundOff"><b>Cudd_addRoundOff</b></a>(
5027  DdManager * <b>dd</b>, <i></i>
5028  DdNode * <b>f</b>, <i></i>
5029  int  <b>N</b> <i></i>
5030)
5031</pre>
5032<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.
5033<p>
5034
5035<dd> <b>Side Effects</b> None
5036<p>
5037
5038<dt><pre>
5039DdNode * <i></i>
5040<a name="Cudd_addScalarInverse"><b>Cudd_addScalarInverse</b></a>(
5041  DdManager * <b>dd</b>, <i></i>
5042  DdNode * <b>f</b>, <i></i>
5043  DdNode * <b>epsilon</b> <i></i>
5044)
5045</pre>
5046<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.
5047<p>
5048
5049<dd> <b>Side Effects</b> None
5050<p>
5051
5052<dt><pre>
5053DdNode * <i></i>
5054<a name="Cudd_addSetNZ"><b>Cudd_addSetNZ</b></a>(
5055  DdManager * <b>dd</b>, <i></i>
5056  DdNode ** <b>f</b>, <i></i>
5057  DdNode ** <b>g</b> <i></i>
5058)
5059</pre>
5060<dd> This operator sets f to the value of g wherever g != 0. Returns NULL if not a terminal case; f op g otherwise.
5061<p>
5062
5063<dd> <b>Side Effects</b> None
5064<p>
5065
5066<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_addApply">Cudd_addApply</a>
5067</code>
5068
5069<dt><pre>
5070DdNode * <i></i>
5071<a name="Cudd_addSwapVariables"><b>Cudd_addSwapVariables</b></a>(
5072  DdManager * <b>dd</b>, <i></i>
5073  DdNode * <b>f</b>, <i></i>
5074  DdNode ** <b>x</b>, <i></i>
5075  DdNode ** <b>y</b>, <i></i>
5076  int  <b>n</b> <i></i>
5077)
5078</pre>
5079<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.
5080<p>
5081
5082<dd> <b>Side Effects</b> None
5083<p>
5084
5085<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_addPermute">Cudd_addPermute</a>
5086<a href="cuddAllDet.html#Cudd_bddSwapVariables">Cudd_bddSwapVariables</a>
5087</code>
5088
5089<dt><pre>
5090DdNode * <i></i>
5091<a name="Cudd_addThreshold"><b>Cudd_addThreshold</b></a>(
5092  DdManager * <b>dd</b>, <i></i>
5093  DdNode ** <b>f</b>, <i></i>
5094  DdNode ** <b>g</b> <i></i>
5095)
5096</pre>
5097<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.
5098<p>
5099
5100<dd> <b>Side Effects</b> None
5101<p>
5102
5103<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_addApply">Cudd_addApply</a>
5104</code>
5105
5106<dt><pre>
5107DdNode * <i></i>
5108<a name="Cudd_addTimesPlus"><b>Cudd_addTimesPlus</b></a>(
5109  DdManager * <b>dd</b>, <i></i>
5110  DdNode * <b>A</b>, <i></i>
5111  DdNode * <b>B</b>, <i></i>
5112  DdNode ** <b>z</b>, <i></i>
5113  int  <b>nz</b> <i></i>
5114)
5115</pre>
5116<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.
5117<p>
5118
5119<dd> <b>Side Effects</b> None
5120<p>
5121
5122<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_addMatrixMultiply">Cudd_addMatrixMultiply</a>
5123</code>
5124
5125<dt><pre>
5126DdNode * <i></i>
5127<a name="Cudd_addTimes"><b>Cudd_addTimes</b></a>(
5128  DdManager * <b>dd</b>, <i></i>
5129  DdNode ** <b>f</b>, <i></i>
5130  DdNode ** <b>g</b> <i></i>
5131)
5132</pre>
5133<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.
5134<p>
5135
5136<dd> <b>Side Effects</b> None
5137<p>
5138
5139<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_addApply">Cudd_addApply</a>
5140</code>
5141
5142<dt><pre>
5143DdNode * <i></i>
5144<a name="Cudd_addTriangle"><b>Cudd_addTriangle</b></a>(
5145  DdManager * <b>dd</b>, <i></i>
5146  DdNode * <b>f</b>, <i></i>
5147  DdNode * <b>g</b>, <i></i>
5148  DdNode ** <b>z</b>, <i></i>
5149  int  <b>nz</b> <i></i>
5150)
5151</pre>
5152<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.
5153<p>
5154
5155<dd> <b>Side Effects</b> None
5156<p>
5157
5158<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_addMatrixMultiply">Cudd_addMatrixMultiply</a>
5159<a href="cuddAllDet.html#Cudd_bddAndAbstract">Cudd_bddAndAbstract</a>
5160</code>
5161
5162<dt><pre>
5163DdNode * <i></i>
5164<a name="Cudd_addUnivAbstract"><b>Cudd_addUnivAbstract</b></a>(
5165  DdManager * <b>manager</b>, <i></i>
5166  DdNode * <b>f</b>, <i></i>
5167  DdNode * <b>cube</b> <i></i>
5168)
5169</pre>
5170<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.
5171<p>
5172
5173<dd> <b>Side Effects</b> None
5174<p>
5175
5176<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_addExistAbstract">Cudd_addExistAbstract</a>
5177<a href="cuddAllDet.html#Cudd_bddUnivAbstract">Cudd_bddUnivAbstract</a>
5178<a href="cuddAllDet.html#Cudd_addOrAbstract">Cudd_addOrAbstract</a>
5179</code>
5180
5181<dt><pre>
5182DdNode * <i></i>
5183<a name="Cudd_addVectorCompose"><b>Cudd_addVectorCompose</b></a>(
5184  DdManager * <b>dd</b>, <i></i>
5185  DdNode * <b>f</b>, <i></i>
5186  DdNode ** <b>vector</b> <i></i>
5187)
5188</pre>
5189<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.
5190<p>
5191
5192<dd> <b>Side Effects</b> None
5193<p>
5194
5195<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_addNonSimCompose">Cudd_addNonSimCompose</a>
5196<a href="cuddAllDet.html#Cudd_addPermute">Cudd_addPermute</a>
5197<a href="cuddAllDet.html#Cudd_addCompose">Cudd_addCompose</a>
5198<a href="cuddAllDet.html#Cudd_bddVectorCompose">Cudd_bddVectorCompose</a>
5199</code>
5200
5201<dt><pre>
5202DdNode * <i></i>
5203<a name="Cudd_addWalsh"><b>Cudd_addWalsh</b></a>(
5204  DdManager * <b>dd</b>, <i></i>
5205  DdNode ** <b>x</b>, <i></i>
5206  DdNode ** <b>y</b>, <i></i>
5207  int  <b>n</b> <i></i>
5208)
5209</pre>
5210<dd> Generates a Walsh matrix in ADD form. Returns a pointer to the matrixi if successful; NULL otherwise.
5211<p>
5212
5213<dd> <b>Side Effects</b> None
5214<p>
5215
5216<dt><pre>
5217DdNode * <i></i>
5218<a name="Cudd_addXeqy"><b>Cudd_addXeqy</b></a>(
5219  DdManager * <b>dd</b>, <i>DD manager</i>
5220  int  <b>N</b>, <i>number of x and y variables</i>
5221  DdNode ** <b>x</b>, <i>array of x variables</i>
5222  DdNode ** <b>y</b> <i>array of y variables</i>
5223)
5224</pre>
5225<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].
5226<p>
5227
5228<dd> <b>Side Effects</b> None
5229<p>
5230
5231<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_Xeqy">Cudd_Xeqy</a>
5232</code>
5233
5234<dt><pre>
5235DdNode * <i></i>
5236<a name="Cudd_addXnor"><b>Cudd_addXnor</b></a>(
5237  DdManager * <b>dd</b>, <i></i>
5238  DdNode ** <b>f</b>, <i></i>
5239  DdNode ** <b>g</b> <i></i>
5240)
5241</pre>
5242<dd> XNOR of two 0-1 ADDs. Returns NULL if not a terminal case; f XNOR g otherwise.
5243<p>
5244
5245<dd> <b>Side Effects</b> None
5246<p>
5247
5248<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_addApply">Cudd_addApply</a>
5249</code>
5250
5251<dt><pre>
5252DdNode * <i></i>
5253<a name="Cudd_addXor"><b>Cudd_addXor</b></a>(
5254  DdManager * <b>dd</b>, <i></i>
5255  DdNode ** <b>f</b>, <i></i>
5256  DdNode ** <b>g</b> <i></i>
5257)
5258</pre>
5259<dd> XOR of two 0-1 ADDs. Returns NULL if not a terminal case; f XOR g otherwise.
5260<p>
5261
5262<dd> <b>Side Effects</b> None
5263<p>
5264
5265<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_addApply">Cudd_addApply</a>
5266</code>
5267
5268<dt><pre>
5269DdNode * <i></i>
5270<a name="Cudd_bddAdjPermuteX"><b>Cudd_bddAdjPermuteX</b></a>(
5271  DdManager * <b>dd</b>, <i></i>
5272  DdNode * <b>B</b>, <i></i>
5273  DdNode ** <b>x</b>, <i></i>
5274  int  <b>n</b> <i></i>
5275)
5276</pre>
5277<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.
5278<p>
5279
5280<dd> <b>Side Effects</b> None
5281<p>
5282
5283<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_bddPermute">Cudd_bddPermute</a>
5284<a href="cuddAllDet.html#Cudd_bddSwapVariables">Cudd_bddSwapVariables</a>
5285<a href="cuddAllDet.html#Cudd_Dxygtdxz">Cudd_Dxygtdxz</a>
5286<a href="cuddAllDet.html#Cudd_Dxygtdyz">Cudd_Dxygtdyz</a>
5287<a href="cuddAllDet.html#Cudd_PrioritySelect">Cudd_PrioritySelect</a>
5288</code>
5289
5290<dt><pre>
5291DdNode * <i></i>
5292<a name="Cudd_bddAndAbstractLimit"><b>Cudd_bddAndAbstractLimit</b></a>(
5293  DdManager * <b>manager</b>, <i></i>
5294  DdNode * <b>f</b>, <i></i>
5295  DdNode * <b>g</b>, <i></i>
5296  DdNode * <b>cube</b>, <i></i>
5297  unsigned int  <b>limit</b> <i></i>
5298)
5299</pre>
5300<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.
5301<p>
5302
5303<dd> <b>Side Effects</b> None
5304<p>
5305
5306<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_bddAndAbstract">Cudd_bddAndAbstract</a>
5307</code>
5308
5309<dt><pre>
5310DdNode * <i></i>
5311<a name="Cudd_bddAndAbstract"><b>Cudd_bddAndAbstract</b></a>(
5312  DdManager * <b>manager</b>, <i></i>
5313  DdNode * <b>f</b>, <i></i>
5314  DdNode * <b>g</b>, <i></i>
5315  DdNode * <b>cube</b> <i></i>
5316)
5317</pre>
5318<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.
5319<p>
5320
5321<dd> <b>Side Effects</b> None
5322<p>
5323
5324<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_addMatrixMultiply">Cudd_addMatrixMultiply</a>
5325<a href="cuddAllDet.html#Cudd_addTriangle">Cudd_addTriangle</a>
5326<a href="cuddAllDet.html#Cudd_bddAnd">Cudd_bddAnd</a>
5327</code>
5328
5329<dt><pre>
5330DdNode * <i></i>
5331<a name="Cudd_bddAndLimit"><b>Cudd_bddAndLimit</b></a>(
5332  DdManager * <b>dd</b>, <i></i>
5333  DdNode * <b>f</b>, <i></i>
5334  DdNode * <b>g</b>, <i></i>
5335  unsigned int  <b>limit</b> <i></i>
5336)
5337</pre>
5338<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.
5339<p>
5340
5341<dd> <b>Side Effects</b> None
5342<p>
5343
5344<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_bddAnd">Cudd_bddAnd</a>
5345</code>
5346
5347<dt><pre>
5348DdNode * <i></i>
5349<a name="Cudd_bddAnd"><b>Cudd_bddAnd</b></a>(
5350  DdManager * <b>dd</b>, <i></i>
5351  DdNode * <b>f</b>, <i></i>
5352  DdNode * <b>g</b> <i></i>
5353)
5354</pre>
5355<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.
5356<p>
5357
5358<dd> <b>Side Effects</b> None
5359<p>
5360
5361<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_bddIte">Cudd_bddIte</a>
5362<a href="cuddAllDet.html#Cudd_addApply">Cudd_addApply</a>
5363<a href="cuddAllDet.html#Cudd_bddAndAbstract">Cudd_bddAndAbstract</a>
5364<a href="cuddAllDet.html#Cudd_bddIntersect">Cudd_bddIntersect</a>
5365<a href="cuddAllDet.html#Cudd_bddOr">Cudd_bddOr</a>
5366<a href="cuddAllDet.html#Cudd_bddNand">Cudd_bddNand</a>
5367<a href="cuddAllDet.html#Cudd_bddNor">Cudd_bddNor</a>
5368<a href="cuddAllDet.html#Cudd_bddXor">Cudd_bddXor</a>
5369<a href="cuddAllDet.html#Cudd_bddXnor">Cudd_bddXnor</a>
5370</code>
5371
5372<dt><pre>
5373int <i></i>
5374<a name="Cudd_bddApproxConjDecomp"><b>Cudd_bddApproxConjDecomp</b></a>(
5375  DdManager * <b>dd</b>, <i>manager</i>
5376  DdNode * <b>f</b>, <i>function to be decomposed</i>
5377  DdNode *** <b>conjuncts</b> <i>address of the first factor</i>
5378)
5379</pre>
5380<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.
5381<p>
5382
5383<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.
5384<p>
5385
5386<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_bddApproxDisjDecomp">Cudd_bddApproxDisjDecomp</a>
5387<a href="cuddAllDet.html#Cudd_bddIterConjDecomp">Cudd_bddIterConjDecomp</a>
5388<a href="cuddAllDet.html#Cudd_bddGenConjDecomp">Cudd_bddGenConjDecomp</a>
5389<a href="cuddAllDet.html#Cudd_bddVarConjDecomp">Cudd_bddVarConjDecomp</a>
5390<a href="cuddAllDet.html#Cudd_RemapOverApprox">Cudd_RemapOverApprox</a>
5391<a href="cuddAllDet.html#Cudd_bddSqueeze">Cudd_bddSqueeze</a>
5392<a href="cuddAllDet.html#Cudd_bddLICompaction">Cudd_bddLICompaction</a>
5393</code>
5394
5395<dt><pre>
5396int <i></i>
5397<a name="Cudd_bddApproxDisjDecomp"><b>Cudd_bddApproxDisjDecomp</b></a>(
5398  DdManager * <b>dd</b>, <i>manager</i>
5399  DdNode * <b>f</b>, <i>function to be decomposed</i>
5400  DdNode *** <b>disjuncts</b> <i>address of the array of the disjuncts</i>
5401)
5402</pre>
5403<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.
5404<p>
5405
5406<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.
5407<p>
5408
5409<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_bddApproxConjDecomp">Cudd_bddApproxConjDecomp</a>
5410<a href="cuddAllDet.html#Cudd_bddIterDisjDecomp">Cudd_bddIterDisjDecomp</a>
5411<a href="cuddAllDet.html#Cudd_bddGenDisjDecomp">Cudd_bddGenDisjDecomp</a>
5412<a href="cuddAllDet.html#Cudd_bddVarDisjDecomp">Cudd_bddVarDisjDecomp</a>
5413</code>
5414
5415<dt><pre>
5416int <i></i>
5417<a name="Cudd_bddBindVar"><b>Cudd_bddBindVar</b></a>(
5418  DdManager * <b>dd</b>, <i>manager</i>
5419  int  <b>index</b> <i>variable index</i>
5420)
5421</pre>
5422<dd> This function sets a flag to prevent sifting of a variable. Returns 1 if successful; 0 otherwise (i.e., invalid variable index).
5423<p>
5424
5425<dd> <b>Side Effects</b> Changes the "bindVar" flag in DdSubtable.
5426<p>
5427
5428<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_bddUnbindVar">Cudd_bddUnbindVar</a>
5429</code>
5430
5431<dt><pre>
5432DdNode * <i></i>
5433<a name="Cudd_bddBooleanDiff"><b>Cudd_bddBooleanDiff</b></a>(
5434  DdManager * <b>manager</b>, <i></i>
5435  DdNode * <b>f</b>, <i></i>
5436  int  <b>x</b> <i></i>
5437)
5438</pre>
5439<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.
5440<p>
5441
5442<dd> <b>Side Effects</b> None
5443<p>
5444
5445<dt><pre>
5446DdNode ** <i></i>
5447<a name="Cudd_bddCharToVect"><b>Cudd_bddCharToVect</b></a>(
5448  DdManager * <b>dd</b>, <i></i>
5449  DdNode * <b>f</b> <i></i>
5450)
5451</pre>
5452<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).
5453<p>
5454
5455<dd> <b>Side Effects</b> None
5456<p>
5457
5458<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_bddConstrain">Cudd_bddConstrain</a>
5459</code>
5460
5461<dt><pre>
5462DdNode * <i></i>
5463<a name="Cudd_bddClippingAndAbstract"><b>Cudd_bddClippingAndAbstract</b></a>(
5464  DdManager * <b>dd</b>, <i>manager</i>
5465  DdNode * <b>f</b>, <i>first conjunct</i>
5466  DdNode * <b>g</b>, <i>second conjunct</i>
5467  DdNode * <b>cube</b>, <i>cube of variables to be abstracted</i>
5468  int  <b>maxDepth</b>, <i>maximum recursion depth</i>
5469  int  <b>direction</b> <i>under (0) or over (1) approximation</i>
5470)
5471</pre>
5472<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.
5473<p>
5474
5475<dd> <b>Side Effects</b> None
5476<p>
5477
5478<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_bddAndAbstract">Cudd_bddAndAbstract</a>
5479<a href="cuddAllDet.html#Cudd_bddClippingAnd">Cudd_bddClippingAnd</a>
5480</code>
5481
5482<dt><pre>
5483DdNode * <i></i>
5484<a name="Cudd_bddClippingAnd"><b>Cudd_bddClippingAnd</b></a>(
5485  DdManager * <b>dd</b>, <i>manager</i>
5486  DdNode * <b>f</b>, <i>first conjunct</i>
5487  DdNode * <b>g</b>, <i>second conjunct</i>
5488  int  <b>maxDepth</b>, <i>maximum recursion depth</i>
5489  int  <b>direction</b> <i>under (0) or over (1) approximation</i>
5490)
5491</pre>
5492<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.
5493<p>
5494
5495<dd> <b>Side Effects</b> None
5496<p>
5497
5498<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_bddAnd">Cudd_bddAnd</a>
5499</code>
5500
5501<dt><pre>
5502DdNode * <i></i>
5503<a name="Cudd_bddClosestCube"><b>Cudd_bddClosestCube</b></a>(
5504  DdManager * <b>dd</b>, <i></i>
5505  DdNode * <b>f</b>, <i></i>
5506  DdNode * <b>g</b>, <i></i>
5507  int * <b>distance</b> <i></i>
5508)
5509</pre>
5510<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.
5511<p>
5512
5513<dd> <b>Side Effects</b> The distance is returned as a side effect.
5514<p>
5515
5516<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_MinHammingDist">Cudd_MinHammingDist</a>
5517</code>
5518
5519<dt><pre>
5520DdNode * <i></i>
5521<a name="Cudd_bddCompose"><b>Cudd_bddCompose</b></a>(
5522  DdManager * <b>dd</b>, <i></i>
5523  DdNode * <b>f</b>, <i></i>
5524  DdNode * <b>g</b>, <i></i>
5525  int  <b>v</b> <i></i>
5526)
5527</pre>
5528<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.
5529<p>
5530
5531<dd> <b>Side Effects</b> None
5532<p>
5533
5534<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_addCompose">Cudd_addCompose</a>
5535</code>
5536
5537<dt><pre>
5538DdNode * <i></i>
5539<a name="Cudd_bddComputeCube"><b>Cudd_bddComputeCube</b></a>(
5540  DdManager * <b>dd</b>, <i></i>
5541  DdNode ** <b>vars</b>, <i></i>
5542  int * <b>phase</b>, <i></i>
5543  int  <b>n</b> <i></i>
5544)
5545</pre>
5546<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.
5547<p>
5548
5549<dd> <b>Side Effects</b> None
5550<p>
5551
5552<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_addComputeCube">Cudd_addComputeCube</a>
5553<a href="cuddAllDet.html#Cudd_IndicesToCube">Cudd_IndicesToCube</a>
5554<a href="cuddAllDet.html#Cudd_CubeArrayToBdd">Cudd_CubeArrayToBdd</a>
5555</code>
5556
5557<dt><pre>
5558DdNode ** <i></i>
5559<a name="Cudd_bddConstrainDecomp"><b>Cudd_bddConstrainDecomp</b></a>(
5560  DdManager * <b>dd</b>, <i></i>
5561  DdNode * <b>f</b> <i></i>
5562)
5563</pre>
5564<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.
5565<p>
5566
5567<dd> <b>Side Effects</b> None
5568<p>
5569
5570<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_bddConstrain">Cudd_bddConstrain</a>
5571<a href="cuddAllDet.html#Cudd_bddExistAbstract">Cudd_bddExistAbstract</a>
5572</code>
5573
5574<dt><pre>
5575DdNode * <i></i>
5576<a name="Cudd_bddConstrain"><b>Cudd_bddConstrain</b></a>(
5577  DdManager * <b>dd</b>, <i></i>
5578  DdNode * <b>f</b>, <i></i>
5579  DdNode * <b>c</b> <i></i>
5580)
5581</pre>
5582<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.
5583<p>
5584
5585<dd> <b>Side Effects</b> None
5586<p>
5587
5588<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_bddRestrict">Cudd_bddRestrict</a>
5589<a href="cuddAllDet.html#Cudd_addConstrain">Cudd_addConstrain</a>
5590</code>
5591
5592<dt><pre>
5593double <i></i>
5594<a name="Cudd_bddCorrelationWeights"><b>Cudd_bddCorrelationWeights</b></a>(
5595  DdManager * <b>manager</b>, <i></i>
5596  DdNode * <b>f</b>, <i></i>
5597  DdNode * <b>g</b>, <i></i>
5598  double * <b>prob</b> <i></i>
5599)
5600</pre>
5601<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.
5602<p>
5603
5604<dd> <b>Side Effects</b> None
5605<p>
5606
5607<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_bddCorrelation">Cudd_bddCorrelation</a>
5608</code>
5609
5610<dt><pre>
5611double <i></i>
5612<a name="Cudd_bddCorrelation"><b>Cudd_bddCorrelation</b></a>(
5613  DdManager * <b>manager</b>, <i></i>
5614  DdNode * <b>f</b>, <i></i>
5615  DdNode * <b>g</b> <i></i>
5616)
5617</pre>
5618<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.
5619<p>
5620
5621<dd> <b>Side Effects</b> None
5622<p>
5623
5624<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_bddCorrelationWeights">Cudd_bddCorrelationWeights</a>
5625</code>
5626
5627<dt><pre>
5628DdNode * <i></i>
5629<a name="Cudd_bddExistAbstract"><b>Cudd_bddExistAbstract</b></a>(
5630  DdManager * <b>manager</b>, <i></i>
5631  DdNode * <b>f</b>, <i></i>
5632  DdNode * <b>cube</b> <i></i>
5633)
5634</pre>
5635<dd> Existentially abstracts all the variables in cube from f. Returns the abstracted BDD if successful; NULL otherwise.
5636<p>
5637
5638<dd> <b>Side Effects</b> None
5639<p>
5640
5641<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_bddUnivAbstract">Cudd_bddUnivAbstract</a>
5642<a href="cuddAllDet.html#Cudd_addExistAbstract">Cudd_addExistAbstract</a>
5643</code>
5644
5645<dt><pre>
5646int <i></i>
5647<a name="Cudd_bddGenConjDecomp"><b>Cudd_bddGenConjDecomp</b></a>(
5648  DdManager * <b>dd</b>, <i>manager</i>
5649  DdNode * <b>f</b>, <i>function to be decomposed</i>
5650  DdNode *** <b>conjuncts</b> <i>address of the array of conjuncts</i>
5651)
5652</pre>
5653<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.
5654<p>
5655
5656<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.
5657<p>
5658
5659<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_bddGenDisjDecomp">Cudd_bddGenDisjDecomp</a>
5660<a href="cuddAllDet.html#Cudd_bddApproxConjDecomp">Cudd_bddApproxConjDecomp</a>
5661<a href="cuddAllDet.html#Cudd_bddIterConjDecomp">Cudd_bddIterConjDecomp</a>
5662<a href="cuddAllDet.html#Cudd_bddVarConjDecomp">Cudd_bddVarConjDecomp</a>
5663</code>
5664
5665<dt><pre>
5666int <i></i>
5667<a name="Cudd_bddGenDisjDecomp"><b>Cudd_bddGenDisjDecomp</b></a>(
5668  DdManager * <b>dd</b>, <i>manager</i>
5669  DdNode * <b>f</b>, <i>function to be decomposed</i>
5670  DdNode *** <b>disjuncts</b> <i>address of the array of the disjuncts</i>
5671)
5672</pre>
5673<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.
5674<p>
5675
5676<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.
5677<p>
5678
5679<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_bddGenConjDecomp">Cudd_bddGenConjDecomp</a>
5680<a href="cuddAllDet.html#Cudd_bddApproxDisjDecomp">Cudd_bddApproxDisjDecomp</a>
5681<a href="cuddAllDet.html#Cudd_bddIterDisjDecomp">Cudd_bddIterDisjDecomp</a>
5682<a href="cuddAllDet.html#Cudd_bddVarDisjDecomp">Cudd_bddVarDisjDecomp</a>
5683</code>
5684
5685<dt><pre>
5686DdNode * <i></i>
5687<a name="Cudd_bddIntersect"><b>Cudd_bddIntersect</b></a>(
5688  DdManager * <b>dd</b>, <i>manager</i>
5689  DdNode * <b>f</b>, <i>first operand</i>
5690  DdNode * <b>g</b> <i>second operand</i>
5691)
5692</pre>
5693<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.
5694<p>
5695
5696<dd> <b>Side Effects</b> None
5697<p>
5698
5699<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_bddLeq">Cudd_bddLeq</a>
5700<a href="cuddAllDet.html#Cudd_bddIteConstant">Cudd_bddIteConstant</a>
5701</code>
5702
5703<dt><pre>
5704int <i></i>
5705<a name="Cudd_bddIsNsVar"><b>Cudd_bddIsNsVar</b></a>(
5706  DdManager * <b>dd</b>, <i></i>
5707  int  <b>index</b> <i></i>
5708)
5709</pre>
5710<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.
5711<p>
5712
5713<dd> <b>Side Effects</b> none
5714<p>
5715
5716<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_bddSetNsVar">Cudd_bddSetNsVar</a>
5717<a href="cuddAllDet.html#Cudd_bddIsPiVar">Cudd_bddIsPiVar</a>
5718<a href="cuddAllDet.html#Cudd_bddIsPsVar">Cudd_bddIsPsVar</a>
5719</code>
5720
5721<dt><pre>
5722int <i></i>
5723<a name="Cudd_bddIsPiVar"><b>Cudd_bddIsPiVar</b></a>(
5724  DdManager * <b>dd</b>, <i>manager</i>
5725  int  <b>index</b> <i>variable index</i>
5726)
5727</pre>
5728<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.
5729<p>
5730
5731<dd> <b>Side Effects</b> none
5732<p>
5733
5734<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_bddSetPiVar">Cudd_bddSetPiVar</a>
5735<a href="cuddAllDet.html#Cudd_bddIsPsVar">Cudd_bddIsPsVar</a>
5736<a href="cuddAllDet.html#Cudd_bddIsNsVar">Cudd_bddIsNsVar</a>
5737</code>
5738
5739<dt><pre>
5740int <i></i>
5741<a name="Cudd_bddIsPsVar"><b>Cudd_bddIsPsVar</b></a>(
5742  DdManager * <b>dd</b>, <i></i>
5743  int  <b>index</b> <i></i>
5744)
5745</pre>
5746<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.
5747<p>
5748
5749<dd> <b>Side Effects</b> none
5750<p>
5751
5752<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_bddSetPsVar">Cudd_bddSetPsVar</a>
5753<a href="cuddAllDet.html#Cudd_bddIsPiVar">Cudd_bddIsPiVar</a>
5754<a href="cuddAllDet.html#Cudd_bddIsNsVar">Cudd_bddIsNsVar</a>
5755</code>
5756
5757<dt><pre>
5758int <i></i>
5759<a name="Cudd_bddIsVarEssential"><b>Cudd_bddIsVarEssential</b></a>(
5760  DdManager * <b>manager</b>, <i></i>
5761  DdNode * <b>f</b>, <i></i>
5762  int  <b>id</b>, <i></i>
5763  int  <b>phase</b> <i></i>
5764)
5765</pre>
5766<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'.
5767<p>
5768
5769<dd> <b>Side Effects</b> None
5770<p>
5771
5772<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_FindEssential">Cudd_FindEssential</a>
5773</code>
5774
5775<dt><pre>
5776int <i></i>
5777<a name="Cudd_bddIsVarHardGroup"><b>Cudd_bddIsVarHardGroup</b></a>(
5778  DdManager * <b>dd</b>, <i></i>
5779  int  <b>index</b> <i></i>
5780)
5781</pre>
5782<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.
5783<p>
5784
5785<dd> <b>Side Effects</b> none
5786<p>
5787
5788<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_bddSetVarHardGroup">Cudd_bddSetVarHardGroup</a>
5789</code>
5790
5791<dt><pre>
5792int <i></i>
5793<a name="Cudd_bddIsVarToBeGrouped"><b>Cudd_bddIsVarToBeGrouped</b></a>(
5794  DdManager * <b>dd</b>, <i></i>
5795  int  <b>index</b> <i></i>
5796)
5797</pre>
5798<dd> Checks whether a variable is set to be grouped. This function is used for lazy sifting.
5799<p>
5800
5801<dd> <b>Side Effects</b> none
5802<p>
5803
5804<dt><pre>
5805int <i></i>
5806<a name="Cudd_bddIsVarToBeUngrouped"><b>Cudd_bddIsVarToBeUngrouped</b></a>(
5807  DdManager * <b>dd</b>, <i></i>
5808  int  <b>index</b> <i></i>
5809)
5810</pre>
5811<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.
5812<p>
5813
5814<dd> <b>Side Effects</b> none
5815<p>
5816
5817<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_bddSetVarToBeUngrouped">Cudd_bddSetVarToBeUngrouped</a>
5818</code>
5819
5820<dt><pre>
5821DdNode  * <i></i>
5822<a name="Cudd_bddIsop"><b>Cudd_bddIsop</b></a>(
5823  DdManager * <b>dd</b>, <i></i>
5824  DdNode * <b>L</b>, <i></i>
5825  DdNode * <b>U</b> <i></i>
5826)
5827</pre>
5828<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.
5829<p>
5830
5831<dd> <b>Side Effects</b> None
5832<p>
5833
5834<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_zddIsop">Cudd_zddIsop</a>
5835</code>
5836
5837<dt><pre>
5838DdNode * <i></i>
5839<a name="Cudd_bddIteConstant"><b>Cudd_bddIteConstant</b></a>(
5840  DdManager * <b>dd</b>, <i></i>
5841  DdNode * <b>f</b>, <i></i>
5842  DdNode * <b>g</b>, <i></i>
5843  DdNode * <b>h</b> <i></i>
5844)
5845</pre>
5846<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.
5847<p>
5848
5849<dd> <b>Side Effects</b> None
5850<p>
5851
5852<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_bddIte">Cudd_bddIte</a>
5853<a href="cuddAllDet.html#Cudd_bddIntersect">Cudd_bddIntersect</a>
5854<a href="cuddAllDet.html#Cudd_bddLeq">Cudd_bddLeq</a>
5855<a href="cuddAllDet.html#Cudd_addIteConstant">Cudd_addIteConstant</a>
5856</code>
5857
5858<dt><pre>
5859int <i></i>
5860<a name="Cudd_bddIterConjDecomp"><b>Cudd_bddIterConjDecomp</b></a>(
5861  DdManager * <b>dd</b>, <i>manager</i>
5862  DdNode * <b>f</b>, <i>function to be decomposed</i>
5863  DdNode *** <b>conjuncts</b> <i>address of the array of conjuncts</i>
5864)
5865</pre>
5866<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.
5867<p>
5868
5869<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.
5870<p>
5871
5872<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_bddIterDisjDecomp">Cudd_bddIterDisjDecomp</a>
5873<a href="cuddAllDet.html#Cudd_bddApproxConjDecomp">Cudd_bddApproxConjDecomp</a>
5874<a href="cuddAllDet.html#Cudd_bddGenConjDecomp">Cudd_bddGenConjDecomp</a>
5875<a href="cuddAllDet.html#Cudd_bddVarConjDecomp">Cudd_bddVarConjDecomp</a>
5876<a href="cuddAllDet.html#Cudd_RemapOverApprox">Cudd_RemapOverApprox</a>
5877<a href="cuddAllDet.html#Cudd_bddSqueeze">Cudd_bddSqueeze</a>
5878<a href="cuddAllDet.html#Cudd_bddLICompaction">Cudd_bddLICompaction</a>
5879</code>
5880
5881<dt><pre>
5882int <i></i>
5883<a name="Cudd_bddIterDisjDecomp"><b>Cudd_bddIterDisjDecomp</b></a>(
5884  DdManager * <b>dd</b>, <i>manager</i>
5885  DdNode * <b>f</b>, <i>function to be decomposed</i>
5886  DdNode *** <b>disjuncts</b> <i>address of the array of the disjuncts</i>
5887)
5888</pre>
5889<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.
5890<p>
5891
5892<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.
5893<p>
5894
5895<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_bddIterConjDecomp">Cudd_bddIterConjDecomp</a>
5896<a href="cuddAllDet.html#Cudd_bddApproxDisjDecomp">Cudd_bddApproxDisjDecomp</a>
5897<a href="cuddAllDet.html#Cudd_bddGenDisjDecomp">Cudd_bddGenDisjDecomp</a>
5898<a href="cuddAllDet.html#Cudd_bddVarDisjDecomp">Cudd_bddVarDisjDecomp</a>
5899</code>
5900
5901<dt><pre>
5902DdNode * <i></i>
5903<a name="Cudd_bddIte"><b>Cudd_bddIte</b></a>(
5904  DdManager * <b>dd</b>, <i></i>
5905  DdNode * <b>f</b>, <i></i>
5906  DdNode * <b>g</b>, <i></i>
5907  DdNode * <b>h</b> <i></i>
5908)
5909</pre>
5910<dd> Implements ITE(f,g,h). Returns a pointer to the resulting BDD if successful; NULL if the intermediate result blows up.
5911<p>
5912
5913<dd> <b>Side Effects</b> None
5914<p>
5915
5916<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_addIte">Cudd_addIte</a>
5917<a href="cuddAllDet.html#Cudd_bddIteConstant">Cudd_bddIteConstant</a>
5918<a href="cuddAllDet.html#Cudd_bddIntersect">Cudd_bddIntersect</a>
5919</code>
5920
5921<dt><pre>
5922DdNode * <i></i>
5923<a name="Cudd_bddIthVar"><b>Cudd_bddIthVar</b></a>(
5924  DdManager * <b>dd</b>, <i></i>
5925  int  <b>i</b> <i></i>
5926)
5927</pre>
5928<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.
5929<p>
5930
5931<dd> <b>Side Effects</b> None
5932<p>
5933
5934<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_bddNewVar">Cudd_bddNewVar</a>
5935<a href="cuddAllDet.html#Cudd_addIthVar">Cudd_addIthVar</a>
5936<a href="cuddAllDet.html#Cudd_bddNewVarAtLevel">Cudd_bddNewVarAtLevel</a>
5937<a href="cuddAllDet.html#Cudd_ReadVars">Cudd_ReadVars</a>
5938</code>
5939
5940<dt><pre>
5941DdNode * <i></i>
5942<a name="Cudd_bddLICompaction"><b>Cudd_bddLICompaction</b></a>(
5943  DdManager * <b>dd</b>, <i>manager</i>
5944  DdNode * <b>f</b>, <i>function to be minimized</i>
5945  DdNode * <b>c</b> <i>constraint (care set)</i>
5946)
5947</pre>
5948<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.
5949<p>
5950
5951<dd> <b>Side Effects</b> None
5952<p>
5953
5954<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_bddRestrict">Cudd_bddRestrict</a>
5955</code>
5956
5957<dt><pre>
5958int <i></i>
5959<a name="Cudd_bddLeqUnless"><b>Cudd_bddLeqUnless</b></a>(
5960  DdManager * <b>dd</b>, <i></i>
5961  DdNode * <b>f</b>, <i></i>
5962  DdNode * <b>g</b>, <i></i>
5963  DdNode * <b>D</b> <i></i>
5964)
5965</pre>
5966<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.
5967<p>
5968
5969<dd> <b>Side Effects</b> None
5970<p>
5971
5972<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_EquivDC">Cudd_EquivDC</a>
5973<a href="cuddAllDet.html#Cudd_bddLeq">Cudd_bddLeq</a>
5974<a href="cuddAllDet.html#Cudd_bddIteConstant">Cudd_bddIteConstant</a>
5975</code>
5976
5977<dt><pre>
5978int <i></i>
5979<a name="Cudd_bddLeq"><b>Cudd_bddLeq</b></a>(
5980  DdManager * <b>dd</b>, <i></i>
5981  DdNode * <b>f</b>, <i></i>
5982  DdNode * <b>g</b> <i></i>
5983)
5984</pre>
5985<dd> Returns 1 if f is less than or equal to g; 0 otherwise. No new nodes are created.
5986<p>
5987
5988<dd> <b>Side Effects</b> None
5989<p>
5990
5991<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_bddIteConstant">Cudd_bddIteConstant</a>
5992<a href="cuddAllDet.html#Cudd_addEvalConst">Cudd_addEvalConst</a>
5993</code>
5994
5995<dt><pre>
5996DdNode * <i></i>
5997<a name="Cudd_bddLiteralSetIntersection"><b>Cudd_bddLiteralSetIntersection</b></a>(
5998  DdManager * <b>dd</b>, <i></i>
5999  DdNode * <b>f</b>, <i></i>
6000  DdNode * <b>g</b> <i></i>
6001)
6002</pre>
6003<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.
6004<p>
6005
6006<dd> <b>Side Effects</b> None
6007<p>
6008
6009<dt><pre>
6010DdNode * <i></i>
6011<a name="Cudd_bddMakePrime"><b>Cudd_bddMakePrime</b></a>(
6012  DdManager * <b>dd</b>, <i>manager</i>
6013  DdNode * <b>cube</b>, <i>cube to be expanded</i>
6014  DdNode * <b>f</b> <i>function of which the cube is to be made a prime</i>
6015)
6016</pre>
6017<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.
6018<p>
6019
6020<dd> <b>Side Effects</b> None
6021<p>
6022
6023<dt><pre>
6024DdNode * <i></i>
6025<a name="Cudd_bddMinimize"><b>Cudd_bddMinimize</b></a>(
6026  DdManager * <b>dd</b>, <i></i>
6027  DdNode * <b>f</b>, <i></i>
6028  DdNode * <b>c</b> <i></i>
6029)
6030</pre>
6031<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.
6032<p>
6033
6034<dd> <b>Side Effects</b> None
6035<p>
6036
6037<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_bddRestrict">Cudd_bddRestrict</a>
6038<a href="cuddAllDet.html#Cudd_bddLICompaction">Cudd_bddLICompaction</a>
6039<a href="cuddAllDet.html#Cudd_bddSqueeze">Cudd_bddSqueeze</a>
6040</code>
6041
6042<dt><pre>
6043DdNode * <i></i>
6044<a name="Cudd_bddNPAnd"><b>Cudd_bddNPAnd</b></a>(
6045  DdManager * <b>dd</b>, <i></i>
6046  DdNode * <b>f</b>, <i></i>
6047  DdNode * <b>g</b> <i></i>
6048)
6049</pre>
6050<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.
6051<p>
6052
6053<dd> <b>Side Effects</b> None
6054<p>
6055
6056<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_bddConstrain">Cudd_bddConstrain</a>
6057<a href="cuddAllDet.html#Cudd_bddRestrict">Cudd_bddRestrict</a>
6058</code>
6059
6060<dt><pre>
6061DdNode * <i></i>
6062<a name="Cudd_bddNand"><b>Cudd_bddNand</b></a>(
6063  DdManager * <b>dd</b>, <i></i>
6064  DdNode * <b>f</b>, <i></i>
6065  DdNode * <b>g</b> <i></i>
6066)
6067</pre>
6068<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.
6069<p>
6070
6071<dd> <b>Side Effects</b> None
6072<p>
6073
6074<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_bddIte">Cudd_bddIte</a>
6075<a href="cuddAllDet.html#Cudd_addApply">Cudd_addApply</a>
6076<a href="cuddAllDet.html#Cudd_bddAnd">Cudd_bddAnd</a>
6077<a href="cuddAllDet.html#Cudd_bddOr">Cudd_bddOr</a>
6078<a href="cuddAllDet.html#Cudd_bddNor">Cudd_bddNor</a>
6079<a href="cuddAllDet.html#Cudd_bddXor">Cudd_bddXor</a>
6080<a href="cuddAllDet.html#Cudd_bddXnor">Cudd_bddXnor</a>
6081</code>
6082
6083<dt><pre>
6084DdNode * <i></i>
6085<a name="Cudd_bddNewVarAtLevel"><b>Cudd_bddNewVarAtLevel</b></a>(
6086  DdManager * <b>dd</b>, <i></i>
6087  int  <b>level</b> <i></i>
6088)
6089</pre>
6090<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.
6091<p>
6092
6093<dd> <b>Side Effects</b> None
6094<p>
6095
6096<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_bddNewVar">Cudd_bddNewVar</a>
6097<a href="cuddAllDet.html#Cudd_bddIthVar">Cudd_bddIthVar</a>
6098<a href="cuddAllDet.html#Cudd_addNewVarAtLevel">Cudd_addNewVarAtLevel</a>
6099</code>
6100
6101<dt><pre>
6102DdNode * <i></i>
6103<a name="Cudd_bddNewVar"><b>Cudd_bddNewVar</b></a>(
6104  DdManager * <b>dd</b> <i></i>
6105)
6106</pre>
6107<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.
6108<p>
6109
6110<dd> <b>Side Effects</b> None
6111<p>
6112
6113<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_addNewVar">Cudd_addNewVar</a>
6114<a href="cuddAllDet.html#Cudd_bddIthVar">Cudd_bddIthVar</a>
6115<a href="cuddAllDet.html#Cudd_bddNewVarAtLevel">Cudd_bddNewVarAtLevel</a>
6116</code>
6117
6118<dt><pre>
6119DdNode * <i></i>
6120<a name="Cudd_bddNor"><b>Cudd_bddNor</b></a>(
6121  DdManager * <b>dd</b>, <i></i>
6122  DdNode * <b>f</b>, <i></i>
6123  DdNode * <b>g</b> <i></i>
6124)
6125</pre>
6126<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.
6127<p>
6128
6129<dd> <b>Side Effects</b> None
6130<p>
6131
6132<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_bddIte">Cudd_bddIte</a>
6133<a href="cuddAllDet.html#Cudd_addApply">Cudd_addApply</a>
6134<a href="cuddAllDet.html#Cudd_bddAnd">Cudd_bddAnd</a>
6135<a href="cuddAllDet.html#Cudd_bddOr">Cudd_bddOr</a>
6136<a href="cuddAllDet.html#Cudd_bddNand">Cudd_bddNand</a>
6137<a href="cuddAllDet.html#Cudd_bddXor">Cudd_bddXor</a>
6138<a href="cuddAllDet.html#Cudd_bddXnor">Cudd_bddXnor</a>
6139</code>
6140
6141<dt><pre>
6142DdNode * <i></i>
6143<a name="Cudd_bddOr"><b>Cudd_bddOr</b></a>(
6144  DdManager * <b>dd</b>, <i></i>
6145  DdNode * <b>f</b>, <i></i>
6146  DdNode * <b>g</b> <i></i>
6147)
6148</pre>
6149<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.
6150<p>
6151
6152<dd> <b>Side Effects</b> None
6153<p>
6154
6155<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_bddIte">Cudd_bddIte</a>
6156<a href="cuddAllDet.html#Cudd_addApply">Cudd_addApply</a>
6157<a href="cuddAllDet.html#Cudd_bddAnd">Cudd_bddAnd</a>
6158<a href="cuddAllDet.html#Cudd_bddNand">Cudd_bddNand</a>
6159<a href="cuddAllDet.html#Cudd_bddNor">Cudd_bddNor</a>
6160<a href="cuddAllDet.html#Cudd_bddXor">Cudd_bddXor</a>
6161<a href="cuddAllDet.html#Cudd_bddXnor">Cudd_bddXnor</a>
6162</code>
6163
6164<dt><pre>
6165DdNode * <i></i>
6166<a name="Cudd_bddPermute"><b>Cudd_bddPermute</b></a>(
6167  DdManager * <b>manager</b>, <i></i>
6168  DdNode * <b>node</b>, <i></i>
6169  int * <b>permut</b> <i></i>
6170)
6171</pre>
6172<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.
6173<p>
6174
6175<dd> <b>Side Effects</b> None
6176<p>
6177
6178<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_addPermute">Cudd_addPermute</a>
6179<a href="cuddAllDet.html#Cudd_bddSwapVariables">Cudd_bddSwapVariables</a>
6180</code>
6181
6182<dt><pre>
6183DdNode ** <i></i>
6184<a name="Cudd_bddPickArbitraryMinterms"><b>Cudd_bddPickArbitraryMinterms</b></a>(
6185  DdManager * <b>dd</b>, <i>manager</i>
6186  DdNode * <b>f</b>, <i>function from which to pick k minterms</i>
6187  DdNode ** <b>vars</b>, <i>array of variables</i>
6188  int  <b>n</b>, <i>size of <code>vars</code></i>
6189  int  <b>k</b> <i>number of minterms to find</i>
6190)
6191</pre>
6192<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>
6193<p>
6194
6195<dd> <b>Side Effects</b> None
6196<p>
6197
6198<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_bddPickOneMinterm">Cudd_bddPickOneMinterm</a>
6199<a href="cuddAllDet.html#Cudd_bddPickOneCube">Cudd_bddPickOneCube</a>
6200</code>
6201
6202<dt><pre>
6203int <i></i>
6204<a name="Cudd_bddPickOneCube"><b>Cudd_bddPickOneCube</b></a>(
6205  DdManager * <b>ddm</b>, <i></i>
6206  DdNode * <b>node</b>, <i></i>
6207  char * <b>string</b> <i></i>
6208)
6209</pre>
6210<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.
6211<p>
6212
6213<dd> <b>Side Effects</b> None
6214<p>
6215
6216<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_bddPickOneMinterm">Cudd_bddPickOneMinterm</a>
6217</code>
6218
6219<dt><pre>
6220DdNode * <i></i>
6221<a name="Cudd_bddPickOneMinterm"><b>Cudd_bddPickOneMinterm</b></a>(
6222  DdManager * <b>dd</b>, <i>manager</i>
6223  DdNode * <b>f</b>, <i>function from which to pick one minterm</i>
6224  DdNode ** <b>vars</b>, <i>array of variables</i>
6225  int  <b>n</b> <i>size of <code>vars</code></i>
6226)
6227</pre>
6228<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>
6229<p>
6230
6231<dd> <b>Side Effects</b> None
6232<p>
6233
6234<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_bddPickOneCube">Cudd_bddPickOneCube</a>
6235</code>
6236
6237<dt><pre>
6238int <i></i>
6239<a name="Cudd_bddPrintCover"><b>Cudd_bddPrintCover</b></a>(
6240  DdManager * <b>dd</b>, <i></i>
6241  DdNode * <b>l</b>, <i></i>
6242  DdNode * <b>u</b> <i></i>
6243)
6244</pre>
6245<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.
6246<p>
6247
6248<dd> <b>Side Effects</b> None
6249<p>
6250
6251<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_PrintMinterm">Cudd_PrintMinterm</a>
6252</code>
6253
6254<dt><pre>
6255int <i></i>
6256<a name="Cudd_bddReadPairIndex"><b>Cudd_bddReadPairIndex</b></a>(
6257  DdManager * <b>dd</b>, <i></i>
6258  int  <b>index</b> <i></i>
6259)
6260</pre>
6261<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.
6262<p>
6263
6264<dd> <b>Side Effects</b> modifies the manager
6265<p>
6266
6267<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_bddSetPairIndex">Cudd_bddSetPairIndex</a>
6268</code>
6269
6270<dt><pre>
6271int <i></i>
6272<a name="Cudd_bddRead"><b>Cudd_bddRead</b></a>(
6273  FILE * <b>fp</b>, <i>input file pointer</i>
6274  DdManager * <b>dd</b>, <i>DD manager</i>
6275  DdNode ** <b>E</b>, <i>characteristic function of the graph</i>
6276  DdNode *** <b>x</b>, <i>array of row variables</i>
6277  DdNode *** <b>y</b>, <i>array of column variables</i>
6278  int * <b>nx</b>, <i>number or row variables</i>
6279  int * <b>ny</b>, <i>number or column variables</i>
6280  int * <b>m</b>, <i>number of rows</i>
6281  int * <b>n</b>, <i>number of columns</i>
6282  int  <b>bx</b>, <i>first index of row variables</i>
6283  int  <b>sx</b>, <i>step of row variables</i>
6284  int  <b>by</b>, <i>first index of column variables</i>
6285  int  <b>sy</b> <i>step of column variables</i>
6286)
6287</pre>
6288<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.
6289<p>
6290
6291<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.
6292<p>
6293
6294<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_addHarwell">Cudd_addHarwell</a>
6295<a href="cuddAllDet.html#Cudd_addRead">Cudd_addRead</a>
6296</code>
6297
6298<dt><pre>
6299void <i></i>
6300<a name="Cudd_bddRealignDisable"><b>Cudd_bddRealignDisable</b></a>(
6301  DdManager * <b>unique</b> <i></i>
6302)
6303</pre>
6304<dd> Disables realignment of ZDD order to BDD order.
6305<p>
6306
6307<dd> <b>Side Effects</b> None
6308<p>
6309
6310<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_bddRealignEnable">Cudd_bddRealignEnable</a>
6311<a href="cuddAllDet.html#Cudd_bddRealignmentEnabled">Cudd_bddRealignmentEnabled</a>
6312<a href="cuddAllDet.html#Cudd_zddRealignEnable">Cudd_zddRealignEnable</a>
6313<a href="cuddAllDet.html#Cudd_zddRealignmentEnabled">Cudd_zddRealignmentEnabled</a>
6314</code>
6315
6316<dt><pre>
6317void <i></i>
6318<a name="Cudd_bddRealignEnable"><b>Cudd_bddRealignEnable</b></a>(
6319  DdManager * <b>unique</b> <i></i>
6320)
6321</pre>
6322<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.
6323<p>
6324
6325<dd> <b>Side Effects</b> None
6326<p>
6327
6328<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_zddReduceHeap">Cudd_zddReduceHeap</a>
6329<a href="cuddAllDet.html#Cudd_bddRealignDisable">Cudd_bddRealignDisable</a>
6330<a href="cuddAllDet.html#Cudd_bddRealignmentEnabled">Cudd_bddRealignmentEnabled</a>
6331<a href="cuddAllDet.html#Cudd_zddRealignDisable">Cudd_zddRealignDisable</a>
6332<a href="cuddAllDet.html#Cudd_zddRealignmentEnabled">Cudd_zddRealignmentEnabled</a>
6333</code>
6334
6335<dt><pre>
6336int <i></i>
6337<a name="Cudd_bddRealignmentEnabled"><b>Cudd_bddRealignmentEnabled</b></a>(
6338  DdManager * <b>unique</b> <i></i>
6339)
6340</pre>
6341<dd> Returns 1 if the realignment of BDD order to ZDD order is enabled; 0 otherwise.
6342<p>
6343
6344<dd> <b>Side Effects</b> None
6345<p>
6346
6347<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_bddRealignEnable">Cudd_bddRealignEnable</a>
6348<a href="cuddAllDet.html#Cudd_bddRealignDisable">Cudd_bddRealignDisable</a>
6349<a href="cuddAllDet.html#Cudd_zddRealignEnable">Cudd_zddRealignEnable</a>
6350<a href="cuddAllDet.html#Cudd_zddRealignDisable">Cudd_zddRealignDisable</a>
6351</code>
6352
6353<dt><pre>
6354int <i></i>
6355<a name="Cudd_bddResetVarToBeGrouped"><b>Cudd_bddResetVarToBeGrouped</b></a>(
6356  DdManager * <b>dd</b>, <i></i>
6357  int  <b>index</b> <i></i>
6358)
6359</pre>
6360<dd> Resets a variable not to be grouped. This function is used for lazy sifting. Returns 1 if successful; 0 otherwise.
6361<p>
6362
6363<dd> <b>Side Effects</b> modifies the manager
6364<p>
6365
6366<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_bddSetVarToBeGrouped">Cudd_bddSetVarToBeGrouped</a>
6367<a href="cuddAllDet.html#Cudd_bddSetVarHardGroup">Cudd_bddSetVarHardGroup</a>
6368</code>
6369
6370<dt><pre>
6371DdNode * <i></i>
6372<a name="Cudd_bddRestrict"><b>Cudd_bddRestrict</b></a>(
6373  DdManager * <b>dd</b>, <i></i>
6374  DdNode * <b>f</b>, <i></i>
6375  DdNode * <b>c</b> <i></i>
6376)
6377</pre>
6378<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.
6379<p>
6380
6381<dd> <b>Side Effects</b> None
6382<p>
6383
6384<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_bddConstrain">Cudd_bddConstrain</a>
6385<a href="cuddAllDet.html#Cudd_addRestrict">Cudd_addRestrict</a>
6386</code>
6387
6388<dt><pre>
6389int <i></i>
6390<a name="Cudd_bddSetNsVar"><b>Cudd_bddSetNsVar</b></a>(
6391  DdManager * <b>dd</b>, <i>manager</i>
6392  int  <b>index</b> <i>variable index</i>
6393)
6394</pre>
6395<dd> Sets a variable type to next state. The variable type is used by lazy sifting. Returns 1 if successful; 0 otherwise.
6396<p>
6397
6398<dd> <b>Side Effects</b> modifies the manager
6399<p>
6400
6401<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_bddSetPiVar">Cudd_bddSetPiVar</a>
6402<a href="cuddAllDet.html#Cudd_bddSetPsVar">Cudd_bddSetPsVar</a>
6403<a href="cuddAllDet.html#Cudd_bddIsNsVar">Cudd_bddIsNsVar</a>
6404</code>
6405
6406<dt><pre>
6407int <i></i>
6408<a name="Cudd_bddSetPairIndex"><b>Cudd_bddSetPairIndex</b></a>(
6409  DdManager * <b>dd</b>, <i>manager</i>
6410  int  <b>index</b>, <i>variable index</i>
6411  int  <b>pairIndex</b> <i>corresponding variable index</i>
6412)
6413</pre>
6414<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.
6415<p>
6416
6417<dd> <b>Side Effects</b> modifies the manager
6418<p>
6419
6420<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_bddReadPairIndex">Cudd_bddReadPairIndex</a>
6421</code>
6422
6423<dt><pre>
6424int <i></i>
6425<a name="Cudd_bddSetPiVar"><b>Cudd_bddSetPiVar</b></a>(
6426  DdManager * <b>dd</b>, <i>manager</i>
6427  int  <b>index</b> <i>variable index</i>
6428)
6429</pre>
6430<dd> Sets a variable type to primary input. The variable type is used by lazy sifting. Returns 1 if successful; 0 otherwise.
6431<p>
6432
6433<dd> <b>Side Effects</b> modifies the manager
6434<p>
6435
6436<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_bddSetPsVar">Cudd_bddSetPsVar</a>
6437<a href="cuddAllDet.html#Cudd_bddSetNsVar">Cudd_bddSetNsVar</a>
6438<a href="cuddAllDet.html#Cudd_bddIsPiVar">Cudd_bddIsPiVar</a>
6439</code>
6440
6441<dt><pre>
6442int <i></i>
6443<a name="Cudd_bddSetPsVar"><b>Cudd_bddSetPsVar</b></a>(
6444  DdManager * <b>dd</b>, <i>manager</i>
6445  int  <b>index</b> <i>variable index</i>
6446)
6447</pre>
6448<dd> Sets a variable type to present state. The variable type is used by lazy sifting. Returns 1 if successful; 0 otherwise.
6449<p>
6450
6451<dd> <b>Side Effects</b> modifies the manager
6452<p>
6453
6454<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_bddSetPiVar">Cudd_bddSetPiVar</a>
6455<a href="cuddAllDet.html#Cudd_bddSetNsVar">Cudd_bddSetNsVar</a>
6456<a href="cuddAllDet.html#Cudd_bddIsPsVar">Cudd_bddIsPsVar</a>
6457</code>
6458
6459<dt><pre>
6460int <i></i>
6461<a name="Cudd_bddSetVarHardGroup"><b>Cudd_bddSetVarHardGroup</b></a>(
6462  DdManager * <b>dd</b>, <i></i>
6463  int  <b>index</b> <i></i>
6464)
6465</pre>
6466<dd> Sets a variable to be a hard group. This function is used for lazy sifting. Returns 1 if successful; 0 otherwise.
6467<p>
6468
6469<dd> <b>Side Effects</b> modifies the manager
6470<p>
6471
6472<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_bddSetVarToBeGrouped">Cudd_bddSetVarToBeGrouped</a>
6473<a href="cuddAllDet.html#Cudd_bddResetVarToBeGrouped">Cudd_bddResetVarToBeGrouped</a>
6474<a href="cuddAllDet.html#Cudd_bddIsVarHardGroup">Cudd_bddIsVarHardGroup</a>
6475</code>
6476
6477<dt><pre>
6478int <i></i>
6479<a name="Cudd_bddSetVarToBeGrouped"><b>Cudd_bddSetVarToBeGrouped</b></a>(
6480  DdManager * <b>dd</b>, <i></i>
6481  int  <b>index</b> <i></i>
6482)
6483</pre>
6484<dd> Sets a variable to be grouped. This function is used for lazy sifting. Returns 1 if successful; 0 otherwise.
6485<p>
6486
6487<dd> <b>Side Effects</b> modifies the manager
6488<p>
6489
6490<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_bddSetVarHardGroup">Cudd_bddSetVarHardGroup</a>
6491<a href="cuddAllDet.html#Cudd_bddResetVarToBeGrouped">Cudd_bddResetVarToBeGrouped</a>
6492</code>
6493
6494<dt><pre>
6495int <i></i>
6496<a name="Cudd_bddSetVarToBeUngrouped"><b>Cudd_bddSetVarToBeUngrouped</b></a>(
6497  DdManager * <b>dd</b>, <i></i>
6498  int  <b>index</b> <i></i>
6499)
6500</pre>
6501<dd> Sets a variable to be ungrouped. This function is used for lazy sifting. Returns 1 if successful; 0 otherwise.
6502<p>
6503
6504<dd> <b>Side Effects</b> modifies the manager
6505<p>
6506
6507<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_bddIsVarToBeUngrouped">Cudd_bddIsVarToBeUngrouped</a>
6508</code>
6509
6510<dt><pre>
6511DdNode * <i></i>
6512<a name="Cudd_bddSqueeze"><b>Cudd_bddSqueeze</b></a>(
6513  DdManager * <b>dd</b>, <i>manager</i>
6514  DdNode * <b>l</b>, <i>lower bound</i>
6515  DdNode * <b>u</b> <i>upper bound</i>
6516)
6517</pre>
6518<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.
6519<p>
6520
6521<dd> <b>Side Effects</b> None
6522<p>
6523
6524<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_bddRestrict">Cudd_bddRestrict</a>
6525<a href="cuddAllDet.html#Cudd_bddLICompaction">Cudd_bddLICompaction</a>
6526</code>
6527
6528<dt><pre>
6529DdNode * <i></i>
6530<a name="Cudd_bddSwapVariables"><b>Cudd_bddSwapVariables</b></a>(
6531  DdManager * <b>dd</b>, <i></i>
6532  DdNode * <b>f</b>, <i></i>
6533  DdNode ** <b>x</b>, <i></i>
6534  DdNode ** <b>y</b>, <i></i>
6535  int  <b>n</b> <i></i>
6536)
6537</pre>
6538<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.
6539<p>
6540
6541<dd> <b>Side Effects</b> None
6542<p>
6543
6544<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_bddPermute">Cudd_bddPermute</a>
6545<a href="cuddAllDet.html#Cudd_addSwapVariables">Cudd_addSwapVariables</a>
6546</code>
6547
6548<dt><pre>
6549DdNode * <i></i>
6550<a name="Cudd_bddTransfer"><b>Cudd_bddTransfer</b></a>(
6551  DdManager * <b>ddSource</b>, <i></i>
6552  DdManager * <b>ddDestination</b>, <i></i>
6553  DdNode * <b>f</b> <i></i>
6554)
6555</pre>
6556<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.
6557<p>
6558
6559<dd> <b>Side Effects</b> None
6560<p>
6561
6562<dt><pre>
6563int <i></i>
6564<a name="Cudd_bddUnbindVar"><b>Cudd_bddUnbindVar</b></a>(
6565  DdManager * <b>dd</b>, <i>manager</i>
6566  int  <b>index</b> <i>variable index</i>
6567)
6568</pre>
6569<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).
6570<p>
6571
6572<dd> <b>Side Effects</b> Changes the "bindVar" flag in DdSubtable.
6573<p>
6574
6575<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_bddBindVar">Cudd_bddBindVar</a>
6576</code>
6577
6578<dt><pre>
6579DdNode * <i></i>
6580<a name="Cudd_bddUnivAbstract"><b>Cudd_bddUnivAbstract</b></a>(
6581  DdManager * <b>manager</b>, <i></i>
6582  DdNode * <b>f</b>, <i></i>
6583  DdNode * <b>cube</b> <i></i>
6584)
6585</pre>
6586<dd> Universally abstracts all the variables in cube from f. Returns the abstracted BDD if successful; NULL otherwise.
6587<p>
6588
6589<dd> <b>Side Effects</b> None
6590<p>
6591
6592<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_bddExistAbstract">Cudd_bddExistAbstract</a>
6593<a href="cuddAllDet.html#Cudd_addUnivAbstract">Cudd_addUnivAbstract</a>
6594</code>
6595
6596<dt><pre>
6597int <i></i>
6598<a name="Cudd_bddVarConjDecomp"><b>Cudd_bddVarConjDecomp</b></a>(
6599  DdManager * <b>dd</b>, <i>manager</i>
6600  DdNode * <b>f</b>, <i>function to be decomposed</i>
6601  DdNode *** <b>conjuncts</b> <i>address of the array of conjuncts</i>
6602)
6603</pre>
6604<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.
6605<p>
6606
6607<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.
6608<p>
6609
6610<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_bddVarDisjDecomp">Cudd_bddVarDisjDecomp</a>
6611<a href="cuddAllDet.html#Cudd_bddGenConjDecomp">Cudd_bddGenConjDecomp</a>
6612<a href="cuddAllDet.html#Cudd_bddApproxConjDecomp">Cudd_bddApproxConjDecomp</a>
6613<a href="cuddAllDet.html#Cudd_bddIterConjDecomp">Cudd_bddIterConjDecomp</a>
6614</code>
6615
6616<dt><pre>
6617int <i></i>
6618<a name="Cudd_bddVarDisjDecomp"><b>Cudd_bddVarDisjDecomp</b></a>(
6619  DdManager * <b>dd</b>, <i>manager</i>
6620  DdNode * <b>f</b>, <i>function to be decomposed</i>
6621  DdNode *** <b>disjuncts</b> <i>address of the array of the disjuncts</i>
6622)
6623</pre>
6624<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.
6625<p>
6626
6627<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.
6628<p>
6629
6630<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_bddVarConjDecomp">Cudd_bddVarConjDecomp</a>
6631<a href="cuddAllDet.html#Cudd_bddApproxDisjDecomp">Cudd_bddApproxDisjDecomp</a>
6632<a href="cuddAllDet.html#Cudd_bddIterDisjDecomp">Cudd_bddIterDisjDecomp</a>
6633<a href="cuddAllDet.html#Cudd_bddGenDisjDecomp">Cudd_bddGenDisjDecomp</a>
6634</code>
6635
6636<dt><pre>
6637int <i></i>
6638<a name="Cudd_bddVarIsBound"><b>Cudd_bddVarIsBound</b></a>(
6639  DdManager * <b>dd</b>, <i>manager</i>
6640  int  <b>index</b> <i>variable index</i>
6641)
6642</pre>
6643<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.
6644<p>
6645
6646<dd> <b>Side Effects</b> none
6647<p>
6648
6649<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_bddBindVar">Cudd_bddBindVar</a>
6650<a href="cuddAllDet.html#Cudd_bddUnbindVar">Cudd_bddUnbindVar</a>
6651</code>
6652
6653<dt><pre>
6654int <i></i>
6655<a name="Cudd_bddVarIsDependent"><b>Cudd_bddVarIsDependent</b></a>(
6656  DdManager * <b>dd</b>, <i></i>
6657  DdNode * <b>f</b>, <i></i>
6658  DdNode * <b>var</b> <i>variable</i>
6659)
6660</pre>
6661<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.
6662<p>
6663
6664<dd> <b>Side Effects</b> None
6665<p>
6666
6667<dt><pre>
6668DdNode * <i></i>
6669<a name="Cudd_bddVarMap"><b>Cudd_bddVarMap</b></a>(
6670  DdManager * <b>manager</b>, <i>DD manager</i>
6671  DdNode * <b>f</b> <i>function in which to remap variables</i>
6672)
6673</pre>
6674<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.
6675<p>
6676
6677<dd> <b>Side Effects</b> None
6678<p>
6679
6680<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_bddPermute">Cudd_bddPermute</a>
6681<a href="cuddAllDet.html#Cudd_bddSwapVariables">Cudd_bddSwapVariables</a>
6682<a href="cuddAllDet.html#Cudd_SetVarMap">Cudd_SetVarMap</a>
6683</code>
6684
6685<dt><pre>
6686DdNode * <i></i>
6687<a name="Cudd_bddVectorCompose"><b>Cudd_bddVectorCompose</b></a>(
6688  DdManager * <b>dd</b>, <i></i>
6689  DdNode * <b>f</b>, <i></i>
6690  DdNode ** <b>vector</b> <i></i>
6691)
6692</pre>
6693<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.
6694<p>
6695
6696<dd> <b>Side Effects</b> None
6697<p>
6698
6699<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_bddPermute">Cudd_bddPermute</a>
6700<a href="cuddAllDet.html#Cudd_bddCompose">Cudd_bddCompose</a>
6701<a href="cuddAllDet.html#Cudd_addVectorCompose">Cudd_addVectorCompose</a>
6702</code>
6703
6704<dt><pre>
6705DdNode * <i></i>
6706<a name="Cudd_bddXnor"><b>Cudd_bddXnor</b></a>(
6707  DdManager * <b>dd</b>, <i></i>
6708  DdNode * <b>f</b>, <i></i>
6709  DdNode * <b>g</b> <i></i>
6710)
6711</pre>
6712<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.
6713<p>
6714
6715<dd> <b>Side Effects</b> None
6716<p>
6717
6718<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_bddIte">Cudd_bddIte</a>
6719<a href="cuddAllDet.html#Cudd_addApply">Cudd_addApply</a>
6720<a href="cuddAllDet.html#Cudd_bddAnd">Cudd_bddAnd</a>
6721<a href="cuddAllDet.html#Cudd_bddOr">Cudd_bddOr</a>
6722<a href="cuddAllDet.html#Cudd_bddNand">Cudd_bddNand</a>
6723<a href="cuddAllDet.html#Cudd_bddNor">Cudd_bddNor</a>
6724<a href="cuddAllDet.html#Cudd_bddXor">Cudd_bddXor</a>
6725</code>
6726
6727<dt><pre>
6728DdNode * <i></i>
6729<a name="Cudd_bddXorExistAbstract"><b>Cudd_bddXorExistAbstract</b></a>(
6730  DdManager * <b>manager</b>, <i></i>
6731  DdNode * <b>f</b>, <i></i>
6732  DdNode * <b>g</b>, <i></i>
6733  DdNode * <b>cube</b> <i></i>
6734)
6735</pre>
6736<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.
6737<p>
6738
6739<dd> <b>Side Effects</b> None
6740<p>
6741
6742<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_bddUnivAbstract">Cudd_bddUnivAbstract</a>
6743<a href="cuddAllDet.html#Cudd_bddExistAbstract">Cudd_bddExistAbstract</a>
6744<a href="cuddAllDet.html#Cudd_bddAndAbstract">Cudd_bddAndAbstract</a>
6745</code>
6746
6747<dt><pre>
6748DdNode * <i></i>
6749<a name="Cudd_bddXor"><b>Cudd_bddXor</b></a>(
6750  DdManager * <b>dd</b>, <i></i>
6751  DdNode * <b>f</b>, <i></i>
6752  DdNode * <b>g</b> <i></i>
6753)
6754</pre>
6755<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.
6756<p>
6757
6758<dd> <b>Side Effects</b> None
6759<p>
6760
6761<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_bddIte">Cudd_bddIte</a>
6762<a href="cuddAllDet.html#Cudd_addApply">Cudd_addApply</a>
6763<a href="cuddAllDet.html#Cudd_bddAnd">Cudd_bddAnd</a>
6764<a href="cuddAllDet.html#Cudd_bddOr">Cudd_bddOr</a>
6765<a href="cuddAllDet.html#Cudd_bddNand">Cudd_bddNand</a>
6766<a href="cuddAllDet.html#Cudd_bddNor">Cudd_bddNor</a>
6767<a href="cuddAllDet.html#Cudd_bddXnor">Cudd_bddXnor</a>
6768</code>
6769
6770<dt><pre>
6771void <i></i>
6772<a name="Cudd_tlcInfoFree"><b>Cudd_tlcInfoFree</b></a>(
6773  DdTlcInfo * <b>t</b> <i></i>
6774)
6775</pre>
6776<dd> Frees a DdTlcInfo Structure as well as the memory pointed by it.
6777<p>
6778
6779<dd> <b>Side Effects</b> None
6780<p>
6781
6782<dt><pre>
6783DdNode * <i></i>
6784<a name="Cudd_zddChange"><b>Cudd_zddChange</b></a>(
6785  DdManager * <b>dd</b>, <i></i>
6786  DdNode * <b>P</b>, <i></i>
6787  int  <b>var</b> <i></i>
6788)
6789</pre>
6790<dd> Substitutes a variable with its complement in a ZDD. returns a pointer to the result if successful; NULL otherwise.
6791<p>
6792
6793<dd> <b>Side Effects</b> None
6794<p>
6795
6796<dt><pre>
6797DdNode  * <i></i>
6798<a name="Cudd_zddComplement"><b>Cudd_zddComplement</b></a>(
6799  DdManager * <b>dd</b>, <i></i>
6800  DdNode * <b>node</b> <i></i>
6801)
6802</pre>
6803<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.
6804<p>
6805
6806<dd> <b>Side Effects</b> The result depends on current variable order.
6807<p>
6808
6809<dt><pre>
6810double <i></i>
6811<a name="Cudd_zddCountDouble"><b>Cudd_zddCountDouble</b></a>(
6812  DdManager * <b>zdd</b>, <i></i>
6813  DdNode * <b>P</b> <i></i>
6814)
6815</pre>
6816<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.
6817<p>
6818
6819<dd> <b>Side Effects</b> None
6820<p>
6821
6822<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_zddCountMinterm">Cudd_zddCountMinterm</a>
6823<a href="cuddAllDet.html#Cudd_zddCount">Cudd_zddCount</a>
6824</code>
6825
6826<dt><pre>
6827double <i></i>
6828<a name="Cudd_zddCountMinterm"><b>Cudd_zddCountMinterm</b></a>(
6829  DdManager * <b>zdd</b>, <i></i>
6830  DdNode * <b>node</b>, <i></i>
6831  int  <b>path</b> <i></i>
6832)
6833</pre>
6834<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.
6835<p>
6836
6837<dd> <b>Side Effects</b> None
6838<p>
6839
6840<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_zddCountDouble">Cudd_zddCountDouble</a>
6841</code>
6842
6843<dt><pre>
6844int <i></i>
6845<a name="Cudd_zddCount"><b>Cudd_zddCount</b></a>(
6846  DdManager * <b>zdd</b>, <i></i>
6847  DdNode * <b>P</b> <i></i>
6848)
6849</pre>
6850<dd> Returns an integer representing the number of minterms in a ZDD.
6851<p>
6852
6853<dd> <b>Side Effects</b> None
6854<p>
6855
6856<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_zddCountDouble">Cudd_zddCountDouble</a>
6857</code>
6858
6859<dt><pre>
6860char * <i></i>
6861<a name="Cudd_zddCoverPathToString"><b>Cudd_zddCoverPathToString</b></a>(
6862  DdManager * <b>zdd</b>, <i>DD manager</i>
6863  int * <b>path</b>, <i>path of ZDD representing a cover</i>
6864  char * <b>str</b> <i>pointer to string to use if != NULL</i>
6865)
6866</pre>
6867<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.
6868<p>
6869
6870<dd> <b>Side Effects</b> None
6871<p>
6872
6873<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_zddForeachPath">Cudd_zddForeachPath</a>
6874</code>
6875
6876<dt><pre>
6877int <i></i>
6878<a name="Cudd_zddDagSize"><b>Cudd_zddDagSize</b></a>(
6879  DdNode * <b>p_node</b> <i></i>
6880)
6881</pre>
6882<dd> Counts the number of nodes in a ZDD. This function duplicates Cudd_DagSize and is only retained for compatibility.
6883<p>
6884
6885<dd> <b>Side Effects</b> None
6886<p>
6887
6888<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_DagSize">Cudd_DagSize</a>
6889</code>
6890
6891<dt><pre>
6892DdNode * <i></i>
6893<a name="Cudd_zddDiffConst"><b>Cudd_zddDiffConst</b></a>(
6894  DdManager * <b>zdd</b>, <i></i>
6895  DdNode * <b>P</b>, <i></i>
6896  DdNode * <b>Q</b> <i></i>
6897)
6898</pre>
6899<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.
6900<p>
6901
6902<dd> <b>Side Effects</b> None
6903<p>
6904
6905<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_zddDiff">Cudd_zddDiff</a>
6906</code>
6907
6908<dt><pre>
6909DdNode * <i></i>
6910<a name="Cudd_zddDiff"><b>Cudd_zddDiff</b></a>(
6911  DdManager * <b>dd</b>, <i></i>
6912  DdNode * <b>P</b>, <i></i>
6913  DdNode * <b>Q</b> <i></i>
6914)
6915</pre>
6916<dd> Computes the difference of two ZDDs. Returns a pointer to the result if successful; NULL otherwise.
6917<p>
6918
6919<dd> <b>Side Effects</b> None
6920<p>
6921
6922<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_zddDiffConst">Cudd_zddDiffConst</a>
6923</code>
6924
6925<dt><pre>
6926DdNode  * <i></i>
6927<a name="Cudd_zddDivideF"><b>Cudd_zddDivideF</b></a>(
6928  DdManager * <b>dd</b>, <i></i>
6929  DdNode * <b>f</b>, <i></i>
6930  DdNode * <b>g</b> <i></i>
6931)
6932</pre>
6933<dd> Modified version of Cudd_zddDivide. This function may disappear in future releases.
6934<p>
6935
6936<dd> <b>Side Effects</b> None
6937<p>
6938
6939<dt><pre>
6940DdNode  * <i></i>
6941<a name="Cudd_zddDivide"><b>Cudd_zddDivide</b></a>(
6942  DdManager * <b>dd</b>, <i></i>
6943  DdNode * <b>f</b>, <i></i>
6944  DdNode * <b>g</b> <i></i>
6945)
6946</pre>
6947<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.
6948<p>
6949
6950<dd> <b>Side Effects</b> None
6951<p>
6952
6953<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_zddWeakDiv">Cudd_zddWeakDiv</a>
6954</code>
6955
6956<dt><pre>
6957int <i></i>
6958<a name="Cudd_zddDumpDot"><b>Cudd_zddDumpDot</b></a>(
6959  DdManager * <b>dd</b>, <i>manager</i>
6960  int  <b>n</b>, <i>number of output nodes to be dumped</i>
6961  DdNode ** <b>f</b>, <i>array of output nodes to be dumped</i>
6962  char ** <b>inames</b>, <i>array of input names (or NULL)</i>
6963  char ** <b>onames</b>, <i>array of output names (or NULL)</i>
6964  FILE * <b>fp</b> <i>pointer to the dump file</i>
6965)
6966</pre>
6967<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.
6968<p>
6969
6970<dd> <b>Side Effects</b> None
6971<p>
6972
6973<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_DumpDot">Cudd_DumpDot</a>
6974<a href="cuddAllDet.html#Cudd_zddPrintDebug">Cudd_zddPrintDebug</a>
6975</code>
6976
6977<dt><pre>
6978DdGen * <i></i>
6979<a name="Cudd_zddFirstPath"><b>Cudd_zddFirstPath</b></a>(
6980  DdManager * <b>zdd</b>, <i></i>
6981  DdNode * <b>f</b>, <i></i>
6982  int ** <b>path</b> <i></i>
6983)
6984</pre>
6985<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.
6986<p>
6987
6988<dd> <b>Side Effects</b> The first path is returned as a side effect.
6989<p>
6990
6991<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_zddForeachPath">Cudd_zddForeachPath</a>
6992<a href="cuddAllDet.html#Cudd_zddNextPath">Cudd_zddNextPath</a>
6993<a href="cuddAllDet.html#Cudd_GenFree">Cudd_GenFree</a>
6994<a href="cuddAllDet.html#Cudd_IsGenEmpty">Cudd_IsGenEmpty</a>
6995</code>
6996
6997<dt><pre>
6998 <i></i>
6999<a name="Cudd_zddForeachPath"><b>Cudd_zddForeachPath</b></a>(
7000   <b>manager</b>, <i></i>
7001   <b>f</b>, <i></i>
7002   <b>gen</b>, <i></i>
7003   <b>path</b> <i></i>
7004)
7005</pre>
7006<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.
7007<p>
7008
7009<dd> <b>Side Effects</b> none
7010<p>
7011
7012<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_zddFirstPath">Cudd_zddFirstPath</a>
7013<a href="cuddAllDet.html#Cudd_zddNextPath">Cudd_zddNextPath</a>
7014<a href="cuddAllDet.html#Cudd_GenFree">Cudd_GenFree</a>
7015<a href="cuddAllDet.html#Cudd_IsGenEmpty">Cudd_IsGenEmpty</a>
7016<a href="cuddAllDet.html#Cudd_AutodynDisable">Cudd_AutodynDisable</a>
7017</code>
7018
7019<dt><pre>
7020DdNode * <i></i>
7021<a name="Cudd_zddIntersect"><b>Cudd_zddIntersect</b></a>(
7022  DdManager * <b>dd</b>, <i></i>
7023  DdNode * <b>P</b>, <i></i>
7024  DdNode * <b>Q</b> <i></i>
7025)
7026</pre>
7027<dd> Computes the intersection of two ZDDs. Returns a pointer to the result if successful; NULL otherwise.
7028<p>
7029
7030<dd> <b>Side Effects</b> None
7031<p>
7032
7033<dt><pre>
7034DdNode  * <i></i>
7035<a name="Cudd_zddIsop"><b>Cudd_zddIsop</b></a>(
7036  DdManager * <b>dd</b>, <i></i>
7037  DdNode * <b>L</b>, <i></i>
7038  DdNode * <b>U</b>, <i></i>
7039  DdNode ** <b>zdd_I</b> <i></i>
7040)
7041</pre>
7042<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.
7043<p>
7044
7045<dd> <b>Side Effects</b> zdd_I holds the pointer to the ZDD for the ISOP on successful return.
7046<p>
7047
7048<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_bddIsop">Cudd_bddIsop</a>
7049<a href="cuddAllDet.html#Cudd_zddVarsFromBddVars">Cudd_zddVarsFromBddVars</a>
7050</code>
7051
7052<dt><pre>
7053DdNode * <i></i>
7054<a name="Cudd_zddIte"><b>Cudd_zddIte</b></a>(
7055  DdManager * <b>dd</b>, <i></i>
7056  DdNode * <b>f</b>, <i></i>
7057  DdNode * <b>g</b>, <i></i>
7058  DdNode * <b>h</b> <i></i>
7059)
7060</pre>
7061<dd> Computes the ITE of three ZDDs. Returns a pointer to the result if successful; NULL otherwise.
7062<p>
7063
7064<dd> <b>Side Effects</b> None
7065<p>
7066
7067<dt><pre>
7068DdNode * <i></i>
7069<a name="Cudd_zddIthVar"><b>Cudd_zddIthVar</b></a>(
7070  DdManager * <b>dd</b>, <i></i>
7071  int  <b>i</b> <i></i>
7072)
7073</pre>
7074<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.
7075<p>
7076
7077<dd> <b>Side Effects</b> None
7078<p>
7079
7080<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_bddIthVar">Cudd_bddIthVar</a>
7081<a href="cuddAllDet.html#Cudd_addIthVar">Cudd_addIthVar</a>
7082</code>
7083
7084<dt><pre>
7085int <i></i>
7086<a name="Cudd_zddNextPath"><b>Cudd_zddNextPath</b></a>(
7087  DdGen * <b>gen</b>, <i></i>
7088  int ** <b>path</b> <i></i>
7089)
7090</pre>
7091<dd> Generates the next path of a ZDD onset, using generator gen. Returns 0 if the enumeration is completed; 1 otherwise.
7092<p>
7093
7094<dd> <b>Side Effects</b> The path is returned as a side effect. The generator is modified.
7095<p>
7096
7097<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_zddForeachPath">Cudd_zddForeachPath</a>
7098<a href="cuddAllDet.html#Cudd_zddFirstPath">Cudd_zddFirstPath</a>
7099<a href="cuddAllDet.html#Cudd_GenFree">Cudd_GenFree</a>
7100<a href="cuddAllDet.html#Cudd_IsGenEmpty">Cudd_IsGenEmpty</a>
7101</code>
7102
7103<dt><pre>
7104DdNode * <i></i>
7105<a name="Cudd_zddPortFromBdd"><b>Cudd_zddPortFromBdd</b></a>(
7106  DdManager * <b>dd</b>, <i></i>
7107  DdNode * <b>B</b> <i></i>
7108)
7109</pre>
7110<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.
7111<p>
7112
7113<dd> <b>Side Effects</b> None
7114<p>
7115
7116<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_zddVarsFromBddVars">Cudd_zddVarsFromBddVars</a>
7117</code>
7118
7119<dt><pre>
7120DdNode * <i></i>
7121<a name="Cudd_zddPortToBdd"><b>Cudd_zddPortToBdd</b></a>(
7122  DdManager * <b>dd</b>, <i></i>
7123  DdNode * <b>f</b> <i></i>
7124)
7125</pre>
7126<dd> Converts a ZDD into a BDD. Returns a pointer to the resulting ZDD if successful; NULL otherwise.
7127<p>
7128
7129<dd> <b>Side Effects</b> None
7130<p>
7131
7132<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_zddPortFromBdd">Cudd_zddPortFromBdd</a>
7133</code>
7134
7135<dt><pre>
7136int <i></i>
7137<a name="Cudd_zddPrintCover"><b>Cudd_zddPrintCover</b></a>(
7138  DdManager * <b>zdd</b>, <i></i>
7139  DdNode * <b>node</b> <i></i>
7140)
7141</pre>
7142<dd> Prints a sum of products from a ZDD representing a cover. Returns 1 if successful; 0 otherwise.
7143<p>
7144
7145<dd> <b>Side Effects</b> None
7146<p>
7147
7148<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_zddPrintMinterm">Cudd_zddPrintMinterm</a>
7149</code>
7150
7151<dt><pre>
7152int <i></i>
7153<a name="Cudd_zddPrintDebug"><b>Cudd_zddPrintDebug</b></a>(
7154  DdManager * <b>zdd</b>, <i></i>
7155  DdNode * <b>f</b>, <i></i>
7156  int  <b>n</b>, <i></i>
7157  int  <b>pr</b> <i></i>
7158)
7159</pre>
7160<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.
7161<p>
7162
7163<dd> <b>Side Effects</b> None
7164<p>
7165
7166<dt><pre>
7167int <i></i>
7168<a name="Cudd_zddPrintMinterm"><b>Cudd_zddPrintMinterm</b></a>(
7169  DdManager * <b>zdd</b>, <i></i>
7170  DdNode * <b>node</b> <i></i>
7171)
7172</pre>
7173<dd> Prints a disjoint sum of product form for a ZDD. Returns 1 if successful; 0 otherwise.
7174<p>
7175
7176<dd> <b>Side Effects</b> None
7177<p>
7178
7179<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_zddPrintDebug">Cudd_zddPrintDebug</a>
7180<a href="cuddAllDet.html#Cudd_zddPrintCover">Cudd_zddPrintCover</a>
7181</code>
7182
7183<dt><pre>
7184void <i></i>
7185<a name="Cudd_zddPrintSubtable"><b>Cudd_zddPrintSubtable</b></a>(
7186  DdManager * <b>table</b> <i></i>
7187)
7188</pre>
7189<dd> Prints the ZDD table for debugging purposes.
7190<p>
7191
7192<dd> <b>Side Effects</b> None
7193<p>
7194
7195<dt><pre>
7196DdNode  * <i></i>
7197<a name="Cudd_zddProduct"><b>Cudd_zddProduct</b></a>(
7198  DdManager * <b>dd</b>, <i></i>
7199  DdNode * <b>f</b>, <i></i>
7200  DdNode * <b>g</b> <i></i>
7201)
7202</pre>
7203<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.
7204<p>
7205
7206<dd> <b>Side Effects</b> None
7207<p>
7208
7209<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_zddUnateProduct">Cudd_zddUnateProduct</a>
7210</code>
7211
7212<dt><pre>
7213long <i></i>
7214<a name="Cudd_zddReadNodeCount"><b>Cudd_zddReadNodeCount</b></a>(
7215  DdManager * <b>dd</b> <i></i>
7216)
7217</pre>
7218<dd> Reports the number of nodes in ZDDs. This number always includes the two constants 1 and 0.
7219<p>
7220
7221<dd> <b>Side Effects</b> None
7222<p>
7223
7224<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_ReadPeakNodeCount">Cudd_ReadPeakNodeCount</a>
7225<a href="cuddAllDet.html#Cudd_ReadNodeCount">Cudd_ReadNodeCount</a>
7226</code>
7227
7228<dt><pre>
7229void <i></i>
7230<a name="Cudd_zddRealignDisable"><b>Cudd_zddRealignDisable</b></a>(
7231  DdManager * <b>unique</b> <i></i>
7232)
7233</pre>
7234<dd> Disables realignment of ZDD order to BDD order.
7235<p>
7236
7237<dd> <b>Side Effects</b> None
7238<p>
7239
7240<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_zddRealignEnable">Cudd_zddRealignEnable</a>
7241<a href="cuddAllDet.html#Cudd_zddRealignmentEnabled">Cudd_zddRealignmentEnabled</a>
7242<a href="cuddAllDet.html#Cudd_bddRealignEnable">Cudd_bddRealignEnable</a>
7243<a href="cuddAllDet.html#Cudd_bddRealignmentEnabled">Cudd_bddRealignmentEnabled</a>
7244</code>
7245
7246<dt><pre>
7247void <i></i>
7248<a name="Cudd_zddRealignEnable"><b>Cudd_zddRealignEnable</b></a>(
7249  DdManager * <b>unique</b> <i></i>
7250)
7251</pre>
7252<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.
7253<p>
7254
7255<dd> <b>Side Effects</b> None
7256<p>
7257
7258<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_ReduceHeap">Cudd_ReduceHeap</a>
7259<a href="cuddAllDet.html#Cudd_zddRealignDisable">Cudd_zddRealignDisable</a>
7260<a href="cuddAllDet.html#Cudd_zddRealignmentEnabled">Cudd_zddRealignmentEnabled</a>
7261<a href="cuddAllDet.html#Cudd_bddRealignDisable">Cudd_bddRealignDisable</a>
7262<a href="cuddAllDet.html#Cudd_bddRealignmentEnabled">Cudd_bddRealignmentEnabled</a>
7263</code>
7264
7265<dt><pre>
7266int <i></i>
7267<a name="Cudd_zddRealignmentEnabled"><b>Cudd_zddRealignmentEnabled</b></a>(
7268  DdManager * <b>unique</b> <i></i>
7269)
7270</pre>
7271<dd> Returns 1 if the realignment of ZDD order to BDD order is enabled; 0 otherwise.
7272<p>
7273
7274<dd> <b>Side Effects</b> None
7275<p>
7276
7277<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_zddRealignEnable">Cudd_zddRealignEnable</a>
7278<a href="cuddAllDet.html#Cudd_zddRealignDisable">Cudd_zddRealignDisable</a>
7279<a href="cuddAllDet.html#Cudd_bddRealignEnable">Cudd_bddRealignEnable</a>
7280<a href="cuddAllDet.html#Cudd_bddRealignDisable">Cudd_bddRealignDisable</a>
7281</code>
7282
7283<dt><pre>
7284int <i></i>
7285<a name="Cudd_zddReduceHeap"><b>Cudd_zddReduceHeap</b></a>(
7286  DdManager * <b>table</b>, <i>DD manager</i>
7287  Cudd_ReorderingType  <b>heuristic</b>, <i>method used for reordering</i>
7288  int  <b>minsize</b> <i>bound below which no reordering occurs</i>
7289)
7290</pre>
7291<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.
7292<p>
7293
7294<dd> <b>Side Effects</b> Changes the variable order for all ZDDs and clears the cache.
7295<p>
7296
7297<dt><pre>
7298int <i></i>
7299<a name="Cudd_zddShuffleHeap"><b>Cudd_zddShuffleHeap</b></a>(
7300  DdManager * <b>table</b>, <i>DD manager</i>
7301  int * <b>permutation</b> <i>required variable permutation</i>
7302)
7303</pre>
7304<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.
7305<p>
7306
7307<dd> <b>Side Effects</b> Changes the ZDD variable order for all diagrams and clears the cache.
7308<p>
7309
7310<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_zddReduceHeap">Cudd_zddReduceHeap</a>
7311</code>
7312
7313<dt><pre>
7314DdNode * <i></i>
7315<a name="Cudd_zddSubset0"><b>Cudd_zddSubset0</b></a>(
7316  DdManager * <b>dd</b>, <i></i>
7317  DdNode * <b>P</b>, <i></i>
7318  int  <b>var</b> <i></i>
7319)
7320</pre>
7321<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.
7322<p>
7323
7324<dd> <b>Side Effects</b> None
7325<p>
7326
7327<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_zddSubset1">Cudd_zddSubset1</a>
7328</code>
7329
7330<dt><pre>
7331DdNode * <i></i>
7332<a name="Cudd_zddSubset1"><b>Cudd_zddSubset1</b></a>(
7333  DdManager * <b>dd</b>, <i></i>
7334  DdNode * <b>P</b>, <i></i>
7335  int  <b>var</b> <i></i>
7336)
7337</pre>
7338<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.
7339<p>
7340
7341<dd> <b>Side Effects</b> None
7342<p>
7343
7344<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_zddSubset0">Cudd_zddSubset0</a>
7345</code>
7346
7347<dt><pre>
7348void <i></i>
7349<a name="Cudd_zddSymmProfile"><b>Cudd_zddSymmProfile</b></a>(
7350  DdManager * <b>table</b>, <i></i>
7351  int  <b>lower</b>, <i></i>
7352  int  <b>upper</b> <i></i>
7353)
7354</pre>
7355<dd> Prints statistics on symmetric ZDD variables.
7356<p>
7357
7358<dd> <b>Side Effects</b> None
7359<p>
7360
7361<dt><pre>
7362DdNode  * <i></i>
7363<a name="Cudd_zddUnateProduct"><b>Cudd_zddUnateProduct</b></a>(
7364  DdManager * <b>dd</b>, <i></i>
7365  DdNode * <b>f</b>, <i></i>
7366  DdNode * <b>g</b> <i></i>
7367)
7368</pre>
7369<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.
7370<p>
7371
7372<dd> <b>Side Effects</b> None
7373<p>
7374
7375<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_zddProduct">Cudd_zddProduct</a>
7376</code>
7377
7378<dt><pre>
7379DdNode * <i></i>
7380<a name="Cudd_zddUnion"><b>Cudd_zddUnion</b></a>(
7381  DdManager * <b>dd</b>, <i></i>
7382  DdNode * <b>P</b>, <i></i>
7383  DdNode * <b>Q</b> <i></i>
7384)
7385</pre>
7386<dd> Computes the union of two ZDDs. Returns a pointer to the result if successful; NULL otherwise.
7387<p>
7388
7389<dd> <b>Side Effects</b> None
7390<p>
7391
7392<dt><pre>
7393int <i></i>
7394<a name="Cudd_zddVarsFromBddVars"><b>Cudd_zddVarsFromBddVars</b></a>(
7395  DdManager * <b>dd</b>, <i>DD manager</i>
7396  int  <b>multiplicity</b> <i>how many ZDD variables are created for each BDD variable</i>
7397)
7398</pre>
7399<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.
7400<p>
7401
7402<dd> <b>Side Effects</b> None
7403<p>
7404
7405<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_bddNewVar">Cudd_bddNewVar</a>
7406<a href="cuddAllDet.html#Cudd_bddIthVar">Cudd_bddIthVar</a>
7407<a href="cuddAllDet.html#Cudd_bddNewVarAtLevel">Cudd_bddNewVarAtLevel</a>
7408</code>
7409
7410<dt><pre>
7411DdNode  * <i></i>
7412<a name="Cudd_zddWeakDivF"><b>Cudd_zddWeakDivF</b></a>(
7413  DdManager * <b>dd</b>, <i></i>
7414  DdNode * <b>f</b>, <i></i>
7415  DdNode * <b>g</b> <i></i>
7416)
7417</pre>
7418<dd> Modified version of Cudd_zddWeakDiv. This function may disappear in future releases.
7419<p>
7420
7421<dd> <b>Side Effects</b> None
7422<p>
7423
7424<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_zddWeakDiv">Cudd_zddWeakDiv</a>
7425</code>
7426
7427<dt><pre>
7428DdNode  * <i></i>
7429<a name="Cudd_zddWeakDiv"><b>Cudd_zddWeakDiv</b></a>(
7430  DdManager * <b>dd</b>, <i></i>
7431  DdNode * <b>f</b>, <i></i>
7432  DdNode * <b>g</b> <i></i>
7433)
7434</pre>
7435<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.
7436<p>
7437
7438<dd> <b>Side Effects</b> None
7439<p>
7440
7441<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_zddDivide">Cudd_zddDivide</a>
7442</code>
7443
7444<dt><pre>
7445 <i></i>
7446<a name="DD_LSDIGIT"><b>DD_LSDIGIT</b></a>(
7447   <b>x</b> <i></i>
7448)
7449</pre>
7450<dd> Extract the least significant digit of a double digit. Used in the manipulation of arbitrary precision integers.
7451<p>
7452
7453<dd> <b>Side Effects</b> None
7454<p>
7455
7456<dd> <b>See Also</b> <code>DD_MSDIGIT
7457</code>
7458
7459<dt><pre>
7460 <i></i>
7461<a name="DD_MINUS_INFINITY"><b>DD_MINUS_INFINITY</b></a>(
7462   <b>dd</b> <i></i>
7463)
7464</pre>
7465<dd> Returns the minus infinity constant node.
7466<p>
7467
7468<dd> <b>Side Effects</b> none
7469<p>
7470
7471<dd> <b>See Also</b> <code>DD_ONE
7472DD_ZERO
7473DD_PLUS_INFINITY
7474</code>
7475
7476<dt><pre>
7477 <i></i>
7478<a name="DD_MSDIGIT"><b>DD_MSDIGIT</b></a>(
7479   <b>x</b> <i></i>
7480)
7481</pre>
7482<dd> Extract the most significant digit of a double digit. Used in the manipulation of arbitrary precision integers.
7483<p>
7484
7485<dd> <b>Side Effects</b> None
7486<p>
7487
7488<dd> <b>See Also</b> <code>DD_LSDIGIT
7489</code>
7490
7491<dt><pre>
7492 <i></i>
7493<a name="DD_ONE"><b>DD_ONE</b></a>(
7494   <b>dd</b> <i></i>
7495)
7496</pre>
7497<dd> Returns the constant 1 node.
7498<p>
7499
7500<dd> <b>Side Effects</b> none
7501<p>
7502
7503<dd> <b>See Also</b> <code>DD_ZERO
7504DD_PLUS_INFINITY
7505DD_MINUS_INFINITY
7506</code>
7507
7508<dt><pre>
7509 <i></i>
7510<a name="DD_PLUS_INFINITY"><b>DD_PLUS_INFINITY</b></a>(
7511   <b>dd</b> <i></i>
7512)
7513</pre>
7514<dd> Returns the plus infinity constant node.
7515<p>
7516
7517<dd> <b>Side Effects</b> none
7518<p>
7519
7520<dd> <b>See Also</b> <code>DD_ONE
7521DD_ZERO
7522DD_MINUS_INFINITY
7523</code>
7524
7525<dt><pre>
7526 <i></i>
7527<a name="DD_ZERO"><b>DD_ZERO</b></a>(
7528   <b>dd</b> <i></i>
7529)
7530</pre>
7531<dd> Returns the arithmetic 0 constant node. This is different from the logical zero. The latter is obtained by Cudd_Not(DD_ONE(dd)).
7532<p>
7533
7534<dd> <b>Side Effects</b> none
7535<p>
7536
7537<dd> <b>See Also</b> <code>DD_ONE
7538<a href="cuddAllDet.html#Cudd_Not">Cudd_Not</a>
7539DD_PLUS_INFINITY
7540DD_MINUS_INFINITY
7541</code>
7542
7543<dt><pre>
7544DdNode * <i></i>
7545<a name="cuddAddApplyRecur"><b>cuddAddApplyRecur</b></a>(
7546  DdManager * <b>dd</b>, <i></i>
7547  DD_AOP  <b>op</b>, <i></i>
7548  DdNode * <b>f</b>, <i></i>
7549  DdNode * <b>g</b> <i></i>
7550)
7551</pre>
7552<dd> Performs the recursive step of Cudd_addApply. Returns a pointer to the result if successful; NULL otherwise.
7553<p>
7554
7555<dd> <b>Side Effects</b> None
7556<p>
7557
7558<dd> <b>See Also</b> <code><a href="cuddAllDet.html#cuddAddMonadicApplyRecur">cuddAddMonadicApplyRecur</a>
7559</code>
7560
7561<dt><pre>
7562DdNode * <i></i>
7563<a name="cuddAddBddDoPattern"><b>cuddAddBddDoPattern</b></a>(
7564  DdManager * <b>dd</b>, <i></i>
7565  DdNode * <b>f</b> <i></i>
7566)
7567</pre>
7568<dd> Performs the recursive step for Cudd_addBddPattern. Returns a pointer to the resulting BDD if successful; NULL otherwise.
7569<p>
7570
7571<dd> <b>Side Effects</b> None
7572<p>
7573
7574<dt><pre>
7575DdNode * <i></i>
7576<a name="cuddAddCmplRecur"><b>cuddAddCmplRecur</b></a>(
7577  DdManager * <b>dd</b>, <i></i>
7578  DdNode * <b>f</b> <i></i>
7579)
7580</pre>
7581<dd> Performs the recursive step of Cudd_addCmpl. Returns a pointer to the resulting ADD if successful; NULL otherwise.
7582<p>
7583
7584<dd> <b>Side Effects</b> None
7585<p>
7586
7587<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_addCmpl">Cudd_addCmpl</a>
7588</code>
7589
7590<dt><pre>
7591DdNode * <i></i>
7592<a name="cuddAddComposeRecur"><b>cuddAddComposeRecur</b></a>(
7593  DdManager * <b>dd</b>, <i></i>
7594  DdNode * <b>f</b>, <i></i>
7595  DdNode * <b>g</b>, <i></i>
7596  DdNode * <b>proj</b> <i></i>
7597)
7598</pre>
7599<dd> Performs the recursive step of Cudd_addCompose. Returns the composed BDD if successful; NULL otherwise.
7600<p>
7601
7602<dd> <b>Side Effects</b> None
7603<p>
7604
7605<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_addCompose">Cudd_addCompose</a>
7606</code>
7607
7608<dt><pre>
7609DdNode * <i></i>
7610<a name="cuddAddConstrainRecur"><b>cuddAddConstrainRecur</b></a>(
7611  DdManager * <b>dd</b>, <i></i>
7612  DdNode * <b>f</b>, <i></i>
7613  DdNode * <b>c</b> <i></i>
7614)
7615</pre>
7616<dd> Performs the recursive step of Cudd_addConstrain. Returns a pointer to the result if successful; NULL otherwise.
7617<p>
7618
7619<dd> <b>Side Effects</b> None
7620<p>
7621
7622<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_addConstrain">Cudd_addConstrain</a>
7623</code>
7624
7625<dt><pre>
7626DdNode * <i></i>
7627<a name="cuddAddExistAbstractRecur"><b>cuddAddExistAbstractRecur</b></a>(
7628  DdManager * <b>manager</b>, <i></i>
7629  DdNode * <b>f</b>, <i></i>
7630  DdNode * <b>cube</b> <i></i>
7631)
7632</pre>
7633<dd> Performs the recursive step of Cudd_addExistAbstract. Returns the ADD obtained by abstracting the variables of cube from f, if successful; NULL otherwise.
7634<p>
7635
7636<dd> <b>Side Effects</b> None
7637<p>
7638
7639<dt><pre>
7640DdNode * <i></i>
7641<a name="cuddAddIteRecur"><b>cuddAddIteRecur</b></a>(
7642  DdManager * <b>dd</b>, <i></i>
7643  DdNode * <b>f</b>, <i></i>
7644  DdNode * <b>g</b>, <i></i>
7645  DdNode * <b>h</b> <i></i>
7646)
7647</pre>
7648<dd> Implements the recursive step of Cudd_addIte(f,g,h). Returns a pointer to the resulting ADD if successful; NULL otherwise.
7649<p>
7650
7651<dd> <b>Side Effects</b> None
7652<p>
7653
7654<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_addIte">Cudd_addIte</a>
7655</code>
7656
7657<dt><pre>
7658DdNode * <i></i>
7659<a name="cuddAddMonadicApplyRecur"><b>cuddAddMonadicApplyRecur</b></a>(
7660  DdManager * <b>dd</b>, <i></i>
7661  DD_MAOP  <b>op</b>, <i></i>
7662  DdNode * <b>f</b> <i></i>
7663)
7664</pre>
7665<dd> Performs the recursive step of Cudd_addMonadicApply. Returns a pointer to the result if successful; NULL otherwise.
7666<p>
7667
7668<dd> <b>Side Effects</b> None
7669<p>
7670
7671<dd> <b>See Also</b> <code><a href="cuddAllDet.html#cuddAddApplyRecur">cuddAddApplyRecur</a>
7672</code>
7673
7674<dt><pre>
7675DdNode * <i></i>
7676<a name="cuddAddNegateRecur"><b>cuddAddNegateRecur</b></a>(
7677  DdManager * <b>dd</b>, <i></i>
7678  DdNode * <b>f</b> <i></i>
7679)
7680</pre>
7681<dd> Implements the recursive step of Cudd_addNegate. Returns a pointer to the result.
7682<p>
7683
7684<dd> <b>Side Effects</b> None
7685<p>
7686
7687<dt><pre>
7688DdNode * <i></i>
7689<a name="cuddAddOrAbstractRecur"><b>cuddAddOrAbstractRecur</b></a>(
7690  DdManager * <b>manager</b>, <i></i>
7691  DdNode * <b>f</b>, <i></i>
7692  DdNode * <b>cube</b> <i></i>
7693)
7694</pre>
7695<dd> Performs the recursive step of Cudd_addOrAbstract. Returns the ADD obtained by abstracting the variables of cube from f, if successful; NULL otherwise.
7696<p>
7697
7698<dd> <b>Side Effects</b> None
7699<p>
7700
7701<dt><pre>
7702DdNode * <i></i>
7703<a name="cuddAddRestrictRecur"><b>cuddAddRestrictRecur</b></a>(
7704  DdManager * <b>dd</b>, <i></i>
7705  DdNode * <b>f</b>, <i></i>
7706  DdNode * <b>c</b> <i></i>
7707)
7708</pre>
7709<dd> Performs the recursive step of Cudd_addRestrict. Returns the restricted ADD if successful; otherwise NULL.
7710<p>
7711
7712<dd> <b>Side Effects</b> None
7713<p>
7714
7715<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_addRestrict">Cudd_addRestrict</a>
7716</code>
7717
7718<dt><pre>
7719DdNode * <i></i>
7720<a name="cuddAddRoundOffRecur"><b>cuddAddRoundOffRecur</b></a>(
7721  DdManager * <b>dd</b>, <i></i>
7722  DdNode * <b>f</b>, <i></i>
7723  double  <b>trunc</b> <i></i>
7724)
7725</pre>
7726<dd> Implements the recursive step of Cudd_addRoundOff. Returns a pointer to the result.
7727<p>
7728
7729<dd> <b>Side Effects</b> None
7730<p>
7731
7732<dt><pre>
7733DdNode * <i></i>
7734<a name="cuddAddScalarInverseRecur"><b>cuddAddScalarInverseRecur</b></a>(
7735  DdManager * <b>dd</b>, <i></i>
7736  DdNode * <b>f</b>, <i></i>
7737  DdNode * <b>epsilon</b> <i></i>
7738)
7739</pre>
7740<dd> Returns a pointer to the resulting ADD in case of success. Returns NULL if any discriminants smaller than epsilon is encountered.
7741<p>
7742
7743<dd> <b>Side Effects</b> None
7744<p>
7745
7746<dt><pre>
7747DdNode * <i></i>
7748<a name="cuddAddUnivAbstractRecur"><b>cuddAddUnivAbstractRecur</b></a>(
7749  DdManager * <b>manager</b>, <i></i>
7750  DdNode * <b>f</b>, <i></i>
7751  DdNode * <b>cube</b> <i></i>
7752)
7753</pre>
7754<dd> Performs the recursive step of Cudd_addUnivAbstract. Returns the ADD obtained by abstracting the variables of cube from f, if successful; NULL otherwise.
7755<p>
7756
7757<dd> <b>Side Effects</b> None
7758<p>
7759
7760<dt><pre>
7761 <i></i>
7762<a name="cuddAdjust"><b>cuddAdjust</b></a>(
7763   <b>x</b> <i></i>
7764)
7765</pre>
7766<dd> Enforces DD_MINUS_INF_VAL <= x <= DD_PLUS_INF_VAL. Furthermore, if x <= DD_MINUS_INF_VAL/2, x is set to DD_MINUS_INF_VAL. Similarly, if DD_PLUS_INF_VAL/2 <= x, x is set to DD_PLUS_INF_VAL. Normally this macro is a NOOP. However, if HAVE_IEEE_754 is not defined, it makes sure that a value does not get larger than infinity in absolute value, and once it gets to infinity, stays there. If the value overflows before this macro is applied, no recovery is possible.
7767<p>
7768
7769<dd> <b>Side Effects</b> none
7770<p>
7771
7772<dt><pre>
7773DdNode * <i></i>
7774<a name="cuddAllocNode"><b>cuddAllocNode</b></a>(
7775  DdManager * <b>unique</b> <i></i>
7776)
7777</pre>
7778<dd> Fast storage allocation for DdNodes in the table. The first 4 bytes of a chunk contain a pointer to the next block; the rest contains DD_MEM_CHUNK spaces for DdNodes. Returns a pointer to a new node if successful; NULL is memory is full.
7779<p>
7780
7781<dd> <b>Side Effects</b> None
7782<p>
7783
7784<dd> <b>See Also</b> <code><a href="cuddAllDet.html#cuddDynamicAllocNode">cuddDynamicAllocNode</a>
7785</code>
7786
7787<dt><pre>
7788int <i></i>
7789<a name="cuddAnnealing"><b>cuddAnnealing</b></a>(
7790  DdManager * <b>table</b>, <i></i>
7791  int  <b>lower</b>, <i></i>
7792  int  <b>upper</b> <i></i>
7793)
7794</pre>
7795<dd> Get x, y by random selection. Choose either exchange or jump randomly. In case of jump, choose between jump_up and jump_down randomly. Do exchange or jump and get optimal case. Loop until there is no improvement or temperature reaches minimum. Returns 1 in case of success; 0 otherwise.
7796<p>
7797
7798<dd> <b>Side Effects</b> None
7799<p>
7800
7801<dt><pre>
7802int <i></i>
7803<a name="cuddBddAlignToZdd"><b>cuddBddAlignToZdd</b></a>(
7804  DdManager * <b>table</b> <i>DD manager</i>
7805)
7806</pre>
7807<dd> Reorders BDD variables according to the order of the ZDD variables. This function can be called at the end of ZDD reordering to insure that the order of the BDD variables is consistent with the order of the ZDD variables. The number of ZDD variables must be a multiple of the number of BDD variables. Let <code>M</code> be the ratio of the two numbers. cuddBddAlignToZdd then considers the ZDD variables from <code>M*i</code> to <code>(M+1)*i-1</code> as corresponding to BDD variable <code>i</code>. This function should be normally called from Cudd_zddReduceHeap, which clears the cache. Returns 1 in case of success; 0 otherwise.
7808<p>
7809
7810<dd> <b>Side Effects</b> Changes the BDD variable order for all diagrams and performs garbage collection of the BDD unique table.
7811<p>
7812
7813<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_ShuffleHeap">Cudd_ShuffleHeap</a>
7814<a href="cuddAllDet.html#Cudd_zddReduceHeap">Cudd_zddReduceHeap</a>
7815</code>
7816
7817<dt><pre>
7818DdNode * <i></i>
7819<a name="cuddBddAndAbstractRecur"><b>cuddBddAndAbstractRecur</b></a>(
7820  DdManager * <b>manager</b>, <i></i>
7821  DdNode * <b>f</b>, <i></i>
7822  DdNode * <b>g</b>, <i></i>
7823  DdNode * <b>cube</b> <i></i>
7824)
7825</pre>
7826<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.
7827<p>
7828
7829<dd> <b>Side Effects</b> None
7830<p>
7831
7832<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_bddAndAbstract">Cudd_bddAndAbstract</a>
7833</code>
7834
7835<dt><pre>
7836DdNode * <i></i>
7837<a name="cuddBddAndRecur"><b>cuddBddAndRecur</b></a>(
7838  DdManager * <b>manager</b>, <i></i>
7839  DdNode * <b>f</b>, <i></i>
7840  DdNode * <b>g</b> <i></i>
7841)
7842</pre>
7843<dd> Implements the recursive step of Cudd_bddAnd by taking the conjunction of two BDDs. Returns a pointer to the result is successful; NULL otherwise.
7844<p>
7845
7846<dd> <b>Side Effects</b> None
7847<p>
7848
7849<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_bddAnd">Cudd_bddAnd</a>
7850</code>
7851
7852<dt><pre>
7853DdNode * <i></i>
7854<a name="cuddBddBooleanDiffRecur"><b>cuddBddBooleanDiffRecur</b></a>(
7855  DdManager * <b>manager</b>, <i></i>
7856  DdNode * <b>f</b>, <i></i>
7857  DdNode * <b>var</b> <i></i>
7858)
7859</pre>
7860<dd> Performs the recursive steps of Cudd_bddBoleanDiff. Returns the BDD obtained by XORing the cofactors of f with respect to var if successful; NULL otherwise. Exploits the fact that dF/dx = dF'/dx.
7861<p>
7862
7863<dd> <b>Side Effects</b> None
7864<p>
7865
7866<dt><pre>
7867DdNode * <i></i>
7868<a name="cuddBddClippingAndAbstract"><b>cuddBddClippingAndAbstract</b></a>(
7869  DdManager * <b>dd</b>, <i>manager</i>
7870  DdNode * <b>f</b>, <i>first conjunct</i>
7871  DdNode * <b>g</b>, <i>second conjunct</i>
7872  DdNode * <b>cube</b>, <i>cube of variables to be abstracted</i>
7873  int  <b>maxDepth</b>, <i>maximum recursion depth</i>
7874  int  <b>direction</b> <i>under (0) or over (1) approximation</i>
7875)
7876</pre>
7877<dd> Approximates the conjunction of two BDDs f and g and simultaneously abstracts the variables in cube. Returns a pointer to the resulting BDD if successful; NULL if the intermediate result blows up.
7878<p>
7879
7880<dd> <b>Side Effects</b> None
7881<p>
7882
7883<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_bddClippingAndAbstract">Cudd_bddClippingAndAbstract</a>
7884</code>
7885
7886<dt><pre>
7887DdNode * <i></i>
7888<a name="cuddBddClippingAnd"><b>cuddBddClippingAnd</b></a>(
7889  DdManager * <b>dd</b>, <i>manager</i>
7890  DdNode * <b>f</b>, <i>first conjunct</i>
7891  DdNode * <b>g</b>, <i>second conjunct</i>
7892  int  <b>maxDepth</b>, <i>maximum recursion depth</i>
7893  int  <b>direction</b> <i>under (0) or over (1) approximation</i>
7894)
7895</pre>
7896<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.
7897<p>
7898
7899<dd> <b>Side Effects</b> None
7900<p>
7901
7902<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_bddClippingAnd">Cudd_bddClippingAnd</a>
7903</code>
7904
7905<dt><pre>
7906DdNode * <i></i>
7907<a name="cuddBddClosestCube"><b>cuddBddClosestCube</b></a>(
7908  DdManager * <b>dd</b>, <i></i>
7909  DdNode * <b>f</b>, <i></i>
7910  DdNode * <b>g</b>, <i></i>
7911  CUDD_VALUE_TYPE  <b>bound</b> <i></i>
7912)
7913</pre>
7914<dd> Performs the recursive step of Cudd_bddClosestCube. Returns the cube if succesful; NULL otherwise. The procedure uses a four-way recursion to examine all four combinations of cofactors of <code>f</code> and <code>g</code> according to the following formula. <pre> H(f,g) = min(H(ft,gt), H(fe,ge), H(ft,ge)+1, H(fe,gt)+1) </pre> Bounding is based on the following observations. <ul> <li> If we already found two points at distance 0, there is no point in continuing. Furthermore, <li> If F == not(G) then the best we can hope for is a minimum distance of 1. If we have already found two points at distance 1, there is no point in continuing. (Indeed, H(F,G) == 1 in this case. We have to continue, though, to find the cube.) </ul> The variable <code>bound</code> is set at the largest value of the distance that we are still interested in. Therefore, we desist when <pre> (bound == -1) and (F != not(G)) or (bound == 0) and (F == not(G)). </pre> If we were maximally aggressive in using the bound, we would always set the bound to the minimum distance seen thus far minus one. That is, we would maintain the invariant <pre> bound < minD, </pre> except at the very beginning, when we have no value for <code>minD</code>.<p> However, we do not use <code>bound < minD</code> when examining the two negative cofactors, because we try to find a large cube at minimum distance. To do so, we try to find a cube in the negative cofactors at the same or smaller distance from the cube found in the positive cofactors.<p> When we compute <code>H(ft,ge)</code> and <code>H(fe,gt)</code> we know that we are going to add 1 to the result of the recursive call to account for the difference in the splitting variable. Therefore, we decrease the bound correspondingly.<p> Another important observation concerns the need of examining all four pairs of cofators only when both <code>f</code> and <code>g</code> depend on the top variable.<p> Suppose <code>gt == ge == g</code>. (That is, <code>g</code> does not depend on the top variable.) Then <pre> H(f,g) = min(H(ft,g), H(fe,g), H(ft,g)+1, H(fe,g)+1) = min(H(ft,g), H(fe,g)) . </pre> Therefore, under these circumstances, we skip the two "cross" cases.<p> An interesting feature of this function is the scheme used for caching the results in the global computed table. Since we have a cube and a distance, we combine them to form an ADD. The combination replaces the zero child of the top node of the cube with the negative of the distance. (The use of the negative is to avoid ambiguity with 1.) The degenerate cases (zero and one) are treated specially because the distance is known (0 for one, and infinity for zero).
7915<p>
7916
7917<dd> <b>Side Effects</b> None
7918<p>
7919
7920<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_bddClosestCube">Cudd_bddClosestCube</a>
7921</code>
7922
7923<dt><pre>
7924DdNode * <i></i>
7925<a name="cuddBddComposeRecur"><b>cuddBddComposeRecur</b></a>(
7926  DdManager * <b>dd</b>, <i></i>
7927  DdNode * <b>f</b>, <i></i>
7928  DdNode * <b>g</b>, <i></i>
7929  DdNode * <b>proj</b> <i></i>
7930)
7931</pre>
7932<dd> Performs the recursive step of Cudd_bddCompose. Exploits the fact that the composition of f' with g produces the complement of the composition of f with g to better utilize the cache. Returns the composed BDD if successful; NULL otherwise.
7933<p>
7934
7935<dd> <b>Side Effects</b> None
7936<p>
7937
7938<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_bddCompose">Cudd_bddCompose</a>
7939</code>
7940
7941<dt><pre>
7942DdNode * <i></i>
7943<a name="cuddBddConstrainRecur"><b>cuddBddConstrainRecur</b></a>(
7944  DdManager * <b>dd</b>, <i></i>
7945  DdNode * <b>f</b>, <i></i>
7946  DdNode * <b>c</b> <i></i>
7947)
7948</pre>
7949<dd> Performs the recursive step of Cudd_bddConstrain. Returns a pointer to the result if successful; NULL otherwise.
7950<p>
7951
7952<dd> <b>Side Effects</b> None
7953<p>
7954
7955<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_bddConstrain">Cudd_bddConstrain</a>
7956</code>
7957
7958<dt><pre>
7959DdNode * <i></i>
7960<a name="cuddBddExistAbstractRecur"><b>cuddBddExistAbstractRecur</b></a>(
7961  DdManager * <b>manager</b>, <i></i>
7962  DdNode * <b>f</b>, <i></i>
7963  DdNode * <b>cube</b> <i></i>
7964)
7965</pre>
7966<dd> Performs the recursive steps of Cudd_bddExistAbstract. Returns the BDD obtained by abstracting the variables of cube from f if successful; NULL otherwise. It is also used by Cudd_bddUnivAbstract.
7967<p>
7968
7969<dd> <b>Side Effects</b> None
7970<p>
7971
7972<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_bddExistAbstract">Cudd_bddExistAbstract</a>
7973<a href="cuddAllDet.html#Cudd_bddUnivAbstract">Cudd_bddUnivAbstract</a>
7974</code>
7975
7976<dt><pre>
7977DdNode * <i></i>
7978<a name="cuddBddIntersectRecur"><b>cuddBddIntersectRecur</b></a>(
7979  DdManager * <b>dd</b>, <i></i>
7980  DdNode * <b>f</b>, <i></i>
7981  DdNode * <b>g</b> <i></i>
7982)
7983</pre>
7984<dd> Implements the recursive step of Cudd_bddIntersect.
7985<p>
7986
7987<dd> <b>Side Effects</b> None
7988<p>
7989
7990<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_bddIntersect">Cudd_bddIntersect</a>
7991</code>
7992
7993<dt><pre>
7994DdNode  * <i></i>
7995<a name="cuddBddIsop"><b>cuddBddIsop</b></a>(
7996  DdManager * <b>dd</b>, <i></i>
7997  DdNode * <b>L</b>, <i></i>
7998  DdNode * <b>U</b> <i></i>
7999)
8000</pre>
8001<dd> Performs the recursive step of Cudd_bddIsop.
8002<p>
8003
8004<dd> <b>Side Effects</b> None
8005<p>
8006
8007<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_bddIsop">Cudd_bddIsop</a>
8008</code>
8009
8010<dt><pre>
8011DdNode * <i></i>
8012<a name="cuddBddIteRecur"><b>cuddBddIteRecur</b></a>(
8013  DdManager * <b>dd</b>, <i></i>
8014  DdNode * <b>f</b>, <i></i>
8015  DdNode * <b>g</b>, <i></i>
8016  DdNode * <b>h</b> <i></i>
8017)
8018</pre>
8019<dd> Implements the recursive step of Cudd_bddIte. Returns a pointer to the resulting BDD. NULL if the intermediate result blows up or if reordering occurs.
8020<p>
8021
8022<dd> <b>Side Effects</b> None
8023<p>
8024
8025<dt><pre>
8026DdNode * <i></i>
8027<a name="cuddBddLICompaction"><b>cuddBddLICompaction</b></a>(
8028  DdManager * <b>dd</b>, <i>manager</i>
8029  DdNode * <b>f</b>, <i>function to be minimized</i>
8030  DdNode * <b>c</b> <i>constraint (care set)</i>
8031)
8032</pre>
8033<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.
8034<p>
8035
8036<dd> <b>Side Effects</b> None
8037<p>
8038
8039<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_bddLICompaction">Cudd_bddLICompaction</a>
8040</code>
8041
8042<dt><pre>
8043DdNode * <i></i>
8044<a name="cuddBddLiteralSetIntersectionRecur"><b>cuddBddLiteralSetIntersectionRecur</b></a>(
8045  DdManager * <b>dd</b>, <i></i>
8046  DdNode * <b>f</b>, <i></i>
8047  DdNode * <b>g</b> <i></i>
8048)
8049</pre>
8050<dd> Performs the recursive step of Cudd_bddLiteralSetIntersection. Scans the cubes for common variables, and checks whether they agree in phase. Returns a pointer to the resulting cube if successful; NULL otherwise.
8051<p>
8052
8053<dd> <b>Side Effects</b> None
8054<p>
8055
8056<dt><pre>
8057DdNode * <i></i>
8058<a name="cuddBddMakePrime"><b>cuddBddMakePrime</b></a>(
8059  DdManager * <b>dd</b>, <i>manager</i>
8060  DdNode * <b>cube</b>, <i>cube to be expanded</i>
8061  DdNode * <b>f</b> <i>function of which the cube is to be made a prime</i>
8062)
8063</pre>
8064<dd> Performs the recursive step of Cudd_bddMakePrime. Returns the prime if successful; NULL otherwise.
8065<p>
8066
8067<dd> <b>Side Effects</b> None
8068<p>
8069
8070<dt><pre>
8071DdNode * <i></i>
8072<a name="cuddBddNPAndRecur"><b>cuddBddNPAndRecur</b></a>(
8073  DdManager * <b>manager</b>, <i></i>
8074  DdNode * <b>f</b>, <i></i>
8075  DdNode * <b>g</b> <i></i>
8076)
8077</pre>
8078<dd> Implements the recursive step of Cudd_bddNPAnd. Returns a pointer to the result is successful; NULL otherwise.
8079<p>
8080
8081<dd> <b>Side Effects</b> None
8082<p>
8083
8084<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_bddNPAnd">Cudd_bddNPAnd</a>
8085</code>
8086
8087<dt><pre>
8088DdNode * <i></i>
8089<a name="cuddBddRestrictRecur"><b>cuddBddRestrictRecur</b></a>(
8090  DdManager * <b>dd</b>, <i></i>
8091  DdNode * <b>f</b>, <i></i>
8092  DdNode * <b>c</b> <i></i>
8093)
8094</pre>
8095<dd> Performs the recursive step of Cudd_bddRestrict. Returns the restricted BDD if successful; otherwise NULL.
8096<p>
8097
8098<dd> <b>Side Effects</b> None
8099<p>
8100
8101<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_bddRestrict">Cudd_bddRestrict</a>
8102</code>
8103
8104<dt><pre>
8105DdNode * <i></i>
8106<a name="cuddBddTransfer"><b>cuddBddTransfer</b></a>(
8107  DdManager * <b>ddS</b>, <i></i>
8108  DdManager * <b>ddD</b>, <i></i>
8109  DdNode * <b>f</b> <i></i>
8110)
8111</pre>
8112<dd> Convert a BDD from a manager to another one. Returns a pointer to the BDD in the destination manager if successful; NULL otherwise.
8113<p>
8114
8115<dd> <b>Side Effects</b> None
8116<p>
8117
8118<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_bddTransfer">Cudd_bddTransfer</a>
8119</code>
8120
8121<dt><pre>
8122DdNode * <i></i>
8123<a name="cuddBddXorExistAbstractRecur"><b>cuddBddXorExistAbstractRecur</b></a>(
8124  DdManager * <b>manager</b>, <i></i>
8125  DdNode * <b>f</b>, <i></i>
8126  DdNode * <b>g</b>, <i></i>
8127  DdNode * <b>cube</b> <i></i>
8128)
8129</pre>
8130<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.
8131<p>
8132
8133<dd> <b>Side Effects</b> None
8134<p>
8135
8136<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_bddAndAbstract">Cudd_bddAndAbstract</a>
8137</code>
8138
8139<dt><pre>
8140DdNode * <i></i>
8141<a name="cuddBddXorRecur"><b>cuddBddXorRecur</b></a>(
8142  DdManager * <b>manager</b>, <i></i>
8143  DdNode * <b>f</b>, <i></i>
8144  DdNode * <b>g</b> <i></i>
8145)
8146</pre>
8147<dd> Implements the recursive step of Cudd_bddXor by taking the exclusive OR of two BDDs. Returns a pointer to the result is successful; NULL otherwise.
8148<p>
8149
8150<dd> <b>Side Effects</b> None
8151<p>
8152
8153<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_bddXor">Cudd_bddXor</a>
8154</code>
8155
8156<dt><pre>
8157DdNode * <i></i>
8158<a name="cuddBiasedUnderApprox"><b>cuddBiasedUnderApprox</b></a>(
8159  DdManager * <b>dd</b>, <i>DD manager</i>
8160  DdNode * <b>f</b>, <i>current DD</i>
8161  DdNode * <b>b</b>, <i>bias function</i>
8162  int  <b>numVars</b>, <i>maximum number of variables</i>
8163  int  <b>threshold</b>, <i>threshold under which approximation stops</i>
8164  double  <b>quality1</b>, <i>minimum improvement for accepted changes when b=1</i>
8165  double  <b>quality0</b> <i>minimum improvement for accepted changes when b=0</i>
8166)
8167</pre>
8168<dd> Applies the biased remapping underappoximation algorithm. Proceeds in three phases: <ul> <li> collect information on each node in the BDD; this is done via DFS. <li> traverse the BDD in top-down fashion and compute for each node whether remapping increases density. <li> traverse the BDD via DFS and actually perform the elimination. </ul> Returns the approximated BDD if successful; NULL otherwise.
8169<p>
8170
8171<dd> <b>Side Effects</b> None
8172<p>
8173
8174<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_BiasedUnderApprox">Cudd_BiasedUnderApprox</a>
8175</code>
8176
8177<dt><pre>
8178DdNode * <i></i>
8179<a name="cuddCProjectionRecur"><b>cuddCProjectionRecur</b></a>(
8180  DdManager * <b>dd</b>, <i></i>
8181  DdNode * <b>R</b>, <i></i>
8182  DdNode * <b>Y</b>, <i></i>
8183  DdNode * <b>Ysupp</b> <i></i>
8184)
8185</pre>
8186<dd> Performs the recursive step of Cudd_CProjection. Returns the projection if successful; NULL otherwise.
8187<p>
8188
8189<dd> <b>Side Effects</b> None
8190<p>
8191
8192<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_CProjection">Cudd_CProjection</a>
8193</code>
8194
8195<dt><pre>
8196void <i></i>
8197<a name="cuddCacheFlush"><b>cuddCacheFlush</b></a>(
8198  DdManager * <b>table</b> <i></i>
8199)
8200</pre>
8201<dd> Flushes the cache.
8202<p>
8203
8204<dd> <b>Side Effects</b> None
8205<p>
8206
8207<dt><pre>
8208void <i></i>
8209<a name="cuddCacheInsert1"><b>cuddCacheInsert1</b></a>(
8210  DdManager * <b>table</b>, <i></i>
8211  DD_CTFP1  <b>op</b>, <i></i>
8212  DdNode * <b>f</b>, <i></i>
8213  DdNode * <b>data</b> <i></i>
8214)
8215</pre>
8216<dd> Inserts a result in the cache for a function with two operands.
8217<p>
8218
8219<dd> <b>Side Effects</b> None
8220<p>
8221
8222<dd> <b>See Also</b> <code><a href="cuddAllDet.html#cuddCacheInsert">cuddCacheInsert</a>
8223<a href="cuddAllDet.html#cuddCacheInsert2">cuddCacheInsert2</a>
8224</code>
8225
8226<dt><pre>
8227void <i></i>
8228<a name="cuddCacheInsert2"><b>cuddCacheInsert2</b></a>(
8229  DdManager * <b>table</b>, <i></i>
8230  DD_CTFP  <b>op</b>, <i></i>
8231  DdNode * <b>f</b>, <i></i>
8232  DdNode * <b>g</b>, <i></i>
8233  DdNode * <b>data</b> <i></i>
8234)
8235</pre>
8236<dd> Inserts a result in the cache for a function with two operands.
8237<p>
8238
8239<dd> <b>Side Effects</b> None
8240<p>
8241
8242<dd> <b>See Also</b> <code><a href="cuddAllDet.html#cuddCacheInsert">cuddCacheInsert</a>
8243<a href="cuddAllDet.html#cuddCacheInsert1">cuddCacheInsert1</a>
8244</code>
8245
8246<dt><pre>
8247void <i></i>
8248<a name="cuddCacheInsert"><b>cuddCacheInsert</b></a>(
8249  DdManager * <b>table</b>, <i></i>
8250  ptruint  <b>op</b>, <i></i>
8251  DdNode * <b>f</b>, <i></i>
8252  DdNode * <b>g</b>, <i></i>
8253  DdNode * <b>h</b>, <i></i>
8254  DdNode * <b>data</b> <i></i>
8255)
8256</pre>
8257<dd> Inserts a result in the cache.
8258<p>
8259
8260<dd> <b>Side Effects</b> None
8261<p>
8262
8263<dd> <b>See Also</b> <code><a href="cuddAllDet.html#cuddCacheInsert2">cuddCacheInsert2</a>
8264<a href="cuddAllDet.html#cuddCacheInsert1">cuddCacheInsert1</a>
8265</code>
8266
8267<dt><pre>
8268DdNode * <i></i>
8269<a name="cuddCacheLookup1Zdd"><b>cuddCacheLookup1Zdd</b></a>(
8270  DdManager * <b>table</b>, <i></i>
8271  DD_CTFP1  <b>op</b>, <i></i>
8272  DdNode * <b>f</b> <i></i>
8273)
8274</pre>
8275<dd> Returns the result if found; it returns NULL if no result is found.
8276<p>
8277
8278<dd> <b>Side Effects</b> None
8279<p>
8280
8281<dd> <b>See Also</b> <code><a href="cuddAllDet.html#cuddCacheLookupZdd">cuddCacheLookupZdd</a>
8282<a href="cuddAllDet.html#cuddCacheLookup2Zdd">cuddCacheLookup2Zdd</a>
8283</code>
8284
8285<dt><pre>
8286DdNode * <i></i>
8287<a name="cuddCacheLookup1"><b>cuddCacheLookup1</b></a>(
8288  DdManager * <b>table</b>, <i></i>
8289  DD_CTFP1  <b>op</b>, <i></i>
8290  DdNode * <b>f</b> <i></i>
8291)
8292</pre>
8293<dd> Returns the result if found; it returns NULL if no result is found.
8294<p>
8295
8296<dd> <b>Side Effects</b> None
8297<p>
8298
8299<dd> <b>See Also</b> <code><a href="cuddAllDet.html#cuddCacheLookup">cuddCacheLookup</a>
8300<a href="cuddAllDet.html#cuddCacheLookup2">cuddCacheLookup2</a>
8301</code>
8302
8303<dt><pre>
8304DdNode * <i></i>
8305<a name="cuddCacheLookup2Zdd"><b>cuddCacheLookup2Zdd</b></a>(
8306  DdManager * <b>table</b>, <i></i>
8307  DD_CTFP  <b>op</b>, <i></i>
8308  DdNode * <b>f</b>, <i></i>
8309  DdNode * <b>g</b> <i></i>
8310)
8311</pre>
8312<dd> Returns the result if found; it returns NULL if no result is found.
8313<p>
8314
8315<dd> <b>Side Effects</b> None
8316<p>
8317
8318<dd> <b>See Also</b> <code><a href="cuddAllDet.html#cuddCacheLookupZdd">cuddCacheLookupZdd</a>
8319<a href="cuddAllDet.html#cuddCacheLookup1Zdd">cuddCacheLookup1Zdd</a>
8320</code>
8321
8322<dt><pre>
8323DdNode * <i></i>
8324<a name="cuddCacheLookup2"><b>cuddCacheLookup2</b></a>(
8325  DdManager * <b>table</b>, <i></i>
8326  DD_CTFP  <b>op</b>, <i></i>
8327  DdNode * <b>f</b>, <i></i>
8328  DdNode * <b>g</b> <i></i>
8329)
8330</pre>
8331<dd> Returns the result if found; it returns NULL if no result is found.
8332<p>
8333
8334<dd> <b>Side Effects</b> None
8335<p>
8336
8337<dd> <b>See Also</b> <code><a href="cuddAllDet.html#cuddCacheLookup">cuddCacheLookup</a>
8338<a href="cuddAllDet.html#cuddCacheLookup1">cuddCacheLookup1</a>
8339</code>
8340
8341<dt><pre>
8342DdNode * <i></i>
8343<a name="cuddCacheLookupZdd"><b>cuddCacheLookupZdd</b></a>(
8344  DdManager * <b>table</b>, <i></i>
8345  ptruint  <b>op</b>, <i></i>
8346  DdNode * <b>f</b>, <i></i>
8347  DdNode * <b>g</b>, <i></i>
8348  DdNode * <b>h</b> <i></i>
8349)
8350</pre>
8351<dd> Returns the result if found; it returns NULL if no result is found.
8352<p>
8353
8354<dd> <b>Side Effects</b> None
8355<p>
8356
8357<dd> <b>See Also</b> <code><a href="cuddAllDet.html#cuddCacheLookup2Zdd">cuddCacheLookup2Zdd</a>
8358<a href="cuddAllDet.html#cuddCacheLookup1Zdd">cuddCacheLookup1Zdd</a>
8359</code>
8360
8361<dt><pre>
8362DdNode * <i></i>
8363<a name="cuddCacheLookup"><b>cuddCacheLookup</b></a>(
8364  DdManager * <b>table</b>, <i></i>
8365  ptruint  <b>op</b>, <i></i>
8366  DdNode * <b>f</b>, <i></i>
8367  DdNode * <b>g</b>, <i></i>
8368  DdNode * <b>h</b> <i></i>
8369)
8370</pre>
8371<dd> Returns the result if found; it returns NULL if no result is found.
8372<p>
8373
8374<dd> <b>Side Effects</b> None
8375<p>
8376
8377<dd> <b>See Also</b> <code><a href="cuddAllDet.html#cuddCacheLookup2">cuddCacheLookup2</a>
8378<a href="cuddAllDet.html#cuddCacheLookup1">cuddCacheLookup1</a>
8379</code>
8380
8381<dt><pre>
8382int <i></i>
8383<a name="cuddCacheProfile"><b>cuddCacheProfile</b></a>(
8384  DdManager * <b>table</b>, <i></i>
8385  FILE * <b>fp</b> <i></i>
8386)
8387</pre>
8388<dd> Computes and prints a profile of the cache usage. Returns 1 if successful; 0 otherwise.
8389<p>
8390
8391<dd> <b>Side Effects</b> None
8392<p>
8393
8394<dt><pre>
8395void <i></i>
8396<a name="cuddCacheResize"><b>cuddCacheResize</b></a>(
8397  DdManager * <b>table</b> <i></i>
8398)
8399</pre>
8400<dd> Resizes the cache.
8401<p>
8402
8403<dd> <b>Side Effects</b> None
8404<p>
8405
8406<dt><pre>
8407int <i></i>
8408<a name="cuddCheckCube"><b>cuddCheckCube</b></a>(
8409  DdManager * <b>dd</b>, <i></i>
8410  DdNode * <b>g</b> <i></i>
8411)
8412</pre>
8413<dd> Checks whether g is the BDD of a cube. Returns 1 in case of success; 0 otherwise. The constant 1 is a valid cube, but all other constant functions cause cuddCheckCube to return 0.
8414<p>
8415
8416<dd> <b>Side Effects</b> None
8417<p>
8418
8419<dt><pre>
8420 <i></i>
8421<a name="cuddClean"><b>cuddClean</b></a>(
8422   <b>p</b> <i></i>
8423)
8424</pre>
8425<dd> Clears the 4 least significant bits of a pointer.
8426<p>
8427
8428<dd> <b>Side Effects</b> none
8429<p>
8430
8431<dt><pre>
8432void <i></i>
8433<a name="cuddClearDeathRow"><b>cuddClearDeathRow</b></a>(
8434  DdManager * <b>table</b> <i></i>
8435)
8436</pre>
8437<dd> Clears the death row.
8438<p>
8439
8440<dd> <b>Side Effects</b> None
8441<p>
8442
8443<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_DelayedDerefBdd">Cudd_DelayedDerefBdd</a>
8444<a href="cuddAllDet.html#Cudd_IterDerefBdd">Cudd_IterDerefBdd</a>
8445<a href="cuddAllDet.html#Cudd_CheckZeroRef">Cudd_CheckZeroRef</a>
8446<a href="cuddAllDet.html#cuddGarbageCollect">cuddGarbageCollect</a>
8447</code>
8448
8449<dt><pre>
8450DdNode * <i></i>
8451<a name="cuddCofactorRecur"><b>cuddCofactorRecur</b></a>(
8452  DdManager * <b>dd</b>, <i></i>
8453  DdNode * <b>f</b>, <i></i>
8454  DdNode * <b>g</b> <i></i>
8455)
8456</pre>
8457<dd> Performs the recursive step of Cudd_Cofactor. Returns a pointer to the cofactor if successful; NULL otherwise.
8458<p>
8459
8460<dd> <b>Side Effects</b> None
8461<p>
8462
8463<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_Cofactor">Cudd_Cofactor</a>
8464</code>
8465
8466<dt><pre>
8467int <i></i>
8468<a name="cuddCollectNodes"><b>cuddCollectNodes</b></a>(
8469  DdNode * <b>f</b>, <i></i>
8470  st_table * <b>visited</b> <i></i>
8471)
8472</pre>
8473<dd> Traverses the DD f and collects all its nodes in a symbol table. f is assumed to be a regular pointer and cuddCollectNodes guarantees this assumption in the recursive calls. Returns 1 in case of success; 0 otherwise.
8474<p>
8475
8476<dd> <b>Side Effects</b> None
8477<p>
8478
8479<dt><pre>
8480int <i></i>
8481<a name="cuddComputeFloorLog2"><b>cuddComputeFloorLog2</b></a>(
8482  unsigned int  <b>value</b> <i></i>
8483)
8484</pre>
8485<dd> Returns the floor of the logarithm to the base 2. The input value is assumed to be greater than 0.
8486<p>
8487
8488<dd> <b>Side Effects</b> None
8489<p>
8490
8491<dt><pre>
8492DdNode * <i></i>
8493<a name="cuddConstantLookup"><b>cuddConstantLookup</b></a>(
8494  DdManager * <b>table</b>, <i></i>
8495  ptruint  <b>op</b>, <i></i>
8496  DdNode * <b>f</b>, <i></i>
8497  DdNode * <b>g</b>, <i></i>
8498  DdNode * <b>h</b> <i></i>
8499)
8500</pre>
8501<dd> Looks up in the cache for the result of op applied to f, g, and h. Assumes that the calling procedure (e.g., Cudd_bddIteConstant) is only interested in whether the result is constant or not. Returns the result if found (possibly DD_NON_CONSTANT); otherwise it returns NULL.
8502<p>
8503
8504<dd> <b>Side Effects</b> None
8505<p>
8506
8507<dd> <b>See Also</b> <code><a href="cuddAllDet.html#cuddCacheLookup">cuddCacheLookup</a>
8508</code>
8509
8510<dt><pre>
8511 <i></i>
8512<a name="cuddDeallocMove"><b>cuddDeallocMove</b></a>(
8513   <b>unique</b>, <i></i>
8514   <b>node</b> <i></i>
8515)
8516</pre>
8517<dd> Adds node to the head of the free list. Does not deallocate memory chunks that become free. This function is also used by the dynamic reordering functions.
8518<p>
8519
8520<dd> <b>Side Effects</b> None
8521<p>
8522
8523<dd> <b>See Also</b> <code><a href="cuddAllDet.html#cuddDeallocNode">cuddDeallocNode</a>
8524<a href="cuddAllDet.html#cuddDynamicAllocNode">cuddDynamicAllocNode</a>
8525</code>
8526
8527<dt><pre>
8528 <i></i>
8529<a name="cuddDeallocNode"><b>cuddDeallocNode</b></a>(
8530   <b>unique</b>, <i></i>
8531   <b>node</b> <i></i>
8532)
8533</pre>
8534<dd> Adds node to the head of the free list. Does not deallocate memory chunks that become free. This function is also used by the dynamic reordering functions.
8535<p>
8536
8537<dd> <b>Side Effects</b> None
8538<p>
8539
8540<dd> <b>See Also</b> <code><a href="cuddAllDet.html#cuddAllocNode">cuddAllocNode</a>
8541<a href="cuddAllDet.html#cuddDynamicAllocNode">cuddDynamicAllocNode</a>
8542<a href="cuddAllDet.html#cuddDeallocMove">cuddDeallocMove</a>
8543</code>
8544
8545<dt><pre>
8546 <i></i>
8547<a name="cuddDeref"><b>cuddDeref</b></a>(
8548   <b>n</b> <i></i>
8549)
8550</pre>
8551<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 cuddRef. This being a macro, it is faster than Cudd_Deref, but it cannot be used in constructs like cuddDeref(a = b()).
8552<p>
8553
8554<dd> <b>Side Effects</b> none
8555<p>
8556
8557<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_Deref">Cudd_Deref</a>
8558</code>
8559
8560<dt><pre>
8561int <i></i>
8562<a name="cuddDestroySubtables"><b>cuddDestroySubtables</b></a>(
8563  DdManager * <b>unique</b>, <i></i>
8564  int  <b>n</b> <i></i>
8565)
8566</pre>
8567<dd> Destroys the n most recently created subtables in a unique table. n should be positive. The subtables should not contain any live nodes, except the (isolated) projection function. The projection functions are freed. Returns 1 if successful; 0 otherwise.
8568<p>
8569
8570<dd> <b>Side Effects</b> The variable map used for fast variable substitution is destroyed if it exists. In this case the cache is also cleared.
8571<p>
8572
8573<dd> <b>See Also</b> <code><a href="cuddAllDet.html#cuddInsertSubtables">cuddInsertSubtables</a>
8574<a href="cuddAllDet.html#Cudd_SetVarMap">Cudd_SetVarMap</a>
8575</code>
8576
8577<dt><pre>
8578DdNode * <i></i>
8579<a name="cuddDynamicAllocNode"><b>cuddDynamicAllocNode</b></a>(
8580  DdManager * <b>table</b> <i></i>
8581)
8582</pre>
8583<dd> Dynamically allocates a Node. This procedure is similar to cuddAllocNode in Cudd_Table.c, but it does not attempt garbage collection, because during reordering there are no dead nodes. Returns a pointer to a new node if successful; NULL is memory is full.
8584<p>
8585
8586<dd> <b>Side Effects</b> None
8587<p>
8588
8589<dd> <b>See Also</b> <code><a href="cuddAllDet.html#cuddAllocNode">cuddAllocNode</a>
8590</code>
8591
8592<dt><pre>
8593int <i></i>
8594<a name="cuddExact"><b>cuddExact</b></a>(
8595  DdManager * <b>table</b>, <i></i>
8596  int  <b>lower</b>, <i></i>
8597  int  <b>upper</b> <i></i>
8598)
8599</pre>
8600<dd> Exact variable ordering algorithm. Finds an optimum order for the variables between lower and upper. Returns 1 if successful; 0 otherwise.
8601<p>
8602
8603<dd> <b>Side Effects</b> None
8604<p>
8605
8606<dt><pre>
8607 <i></i>
8608<a name="cuddE"><b>cuddE</b></a>(
8609   <b>node</b> <i></i>
8610)
8611</pre>
8612<dd> Returns the else child of an internal node. If <code>node</code> is a constant node, the result is unpredictable. The pointer passed to cuddE must be regular.
8613<p>
8614
8615<dd> <b>Side Effects</b> none
8616<p>
8617
8618<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_E">Cudd_E</a>
8619</code>
8620
8621<dt><pre>
8622void <i></i>
8623<a name="cuddFreeTable"><b>cuddFreeTable</b></a>(
8624  DdManager * <b>unique</b> <i></i>
8625)
8626</pre>
8627<dd> Frees the resources associated to a unique table.
8628<p>
8629
8630<dd> <b>Side Effects</b> None
8631<p>
8632
8633<dd> <b>See Also</b> <code><a href="cuddAllDet.html#cuddInitTable">cuddInitTable</a>
8634</code>
8635
8636<dt><pre>
8637int <i></i>
8638<a name="cuddGarbageCollect"><b>cuddGarbageCollect</b></a>(
8639  DdManager * <b>unique</b>, <i></i>
8640  int  <b>clearCache</b> <i></i>
8641)
8642</pre>
8643<dd> Performs garbage collection on the BDD and ZDD unique tables. If clearCache is 0, the cache is not cleared. This should only be specified if the cache has been cleared right before calling cuddGarbageCollect. (As in the case of dynamic reordering.) Returns the total number of deleted nodes.
8644<p>
8645
8646<dd> <b>Side Effects</b> None
8647<p>
8648
8649<dt><pre>
8650int <i></i>
8651<a name="cuddGa"><b>cuddGa</b></a>(
8652  DdManager * <b>table</b>, <i>manager</i>
8653  int  <b>lower</b>, <i>lowest level to be reordered</i>
8654  int  <b>upper</b> <i>highest level to be reorderded</i>
8655)
8656</pre>
8657<dd> Genetic algorithm for DD reordering. The two children of a crossover will be stored in storedd[popsize
8658<p>
8659
8660<dd> <b>Side Effects</b> None
8661<p>
8662
8663<dt><pre>
8664void <i></i>
8665<a name="cuddGetBranches"><b>cuddGetBranches</b></a>(
8666  DdNode * <b>g</b>, <i></i>
8667  DdNode ** <b>g1</b>, <i></i>
8668  DdNode ** <b>g0</b> <i></i>
8669)
8670</pre>
8671<dd> Computes the children of g.
8672<p>
8673
8674<dd> <b>Side Effects</b> None
8675<p>
8676
8677<dt><pre>
8678DdHashTable * <i></i>
8679<a name="cuddHashTableInit"><b>cuddHashTableInit</b></a>(
8680  DdManager * <b>manager</b>, <i></i>
8681  unsigned int  <b>keySize</b>, <i></i>
8682  unsigned int  <b>initSize</b> <i></i>
8683)
8684</pre>
8685<dd> Initializes a hash table. Returns a pointer to the new table if successful; NULL otherwise.
8686<p>
8687
8688<dd> <b>Side Effects</b> None
8689<p>
8690
8691<dd> <b>See Also</b> <code><a href="cuddAllDet.html#cuddHashTableQuit">cuddHashTableQuit</a>
8692</code>
8693
8694<dt><pre>
8695int <i></i>
8696<a name="cuddHashTableInsert1"><b>cuddHashTableInsert1</b></a>(
8697  DdHashTable * <b>hash</b>, <i></i>
8698  DdNode * <b>f</b>, <i></i>
8699  DdNode * <b>value</b>, <i></i>
8700  ptrint  <b>count</b> <i></i>
8701)
8702</pre>
8703<dd> Inserts an item in a hash table when the key is one pointer. Returns 1 if successful; 0 otherwise.
8704<p>
8705
8706<dd> <b>Side Effects</b> None
8707<p>
8708
8709<dd> <b>See Also</b> <code><a href="cuddAllDet.html#cuddHashTableInsert">cuddHashTableInsert</a>
8710<a href="cuddAllDet.html#cuddHashTableInsert2">cuddHashTableInsert2</a>
8711<a href="cuddAllDet.html#cuddHashTableInsert3">cuddHashTableInsert3</a>
8712<a href="cuddAllDet.html#cuddHashTableLookup1">cuddHashTableLookup1</a>
8713</code>
8714
8715<dt><pre>
8716int <i></i>
8717<a name="cuddHashTableInsert2"><b>cuddHashTableInsert2</b></a>(
8718  DdHashTable * <b>hash</b>, <i></i>
8719  DdNode * <b>f</b>, <i></i>
8720  DdNode * <b>g</b>, <i></i>
8721  DdNode * <b>value</b>, <i></i>
8722  ptrint  <b>count</b> <i></i>
8723)
8724</pre>
8725<dd> Inserts an item in a hash table when the key is composed of two pointers. Returns 1 if successful; 0 otherwise.
8726<p>
8727
8728<dd> <b>Side Effects</b> None
8729<p>
8730
8731<dd> <b>See Also</b> <code><a href="cuddAllDet.html#cuddHashTableInsert">cuddHashTableInsert</a>
8732<a href="cuddAllDet.html#cuddHashTableInsert1">cuddHashTableInsert1</a>
8733<a href="cuddAllDet.html#cuddHashTableInsert3">cuddHashTableInsert3</a>
8734<a href="cuddAllDet.html#cuddHashTableLookup2">cuddHashTableLookup2</a>
8735</code>
8736
8737<dt><pre>
8738int <i></i>
8739<a name="cuddHashTableInsert3"><b>cuddHashTableInsert3</b></a>(
8740  DdHashTable * <b>hash</b>, <i></i>
8741  DdNode * <b>f</b>, <i></i>
8742  DdNode * <b>g</b>, <i></i>
8743  DdNode * <b>h</b>, <i></i>
8744  DdNode * <b>value</b>, <i></i>
8745  ptrint  <b>count</b> <i></i>
8746)
8747</pre>
8748<dd> Inserts an item in a hash table when the key is composed of three pointers. Returns 1 if successful; 0 otherwise.
8749<p>
8750
8751<dd> <b>Side Effects</b> None
8752<p>
8753
8754<dd> <b>See Also</b> <code><a href="cuddAllDet.html#cuddHashTableInsert">cuddHashTableInsert</a>
8755<a href="cuddAllDet.html#cuddHashTableInsert1">cuddHashTableInsert1</a>
8756<a href="cuddAllDet.html#cuddHashTableInsert2">cuddHashTableInsert2</a>
8757<a href="cuddAllDet.html#cuddHashTableLookup3">cuddHashTableLookup3</a>
8758</code>
8759
8760<dt><pre>
8761int <i></i>
8762<a name="cuddHashTableInsert"><b>cuddHashTableInsert</b></a>(
8763  DdHashTable * <b>hash</b>, <i></i>
8764  DdNodePtr * <b>key</b>, <i></i>
8765  DdNode * <b>value</b>, <i></i>
8766  ptrint  <b>count</b> <i></i>
8767)
8768</pre>
8769<dd> Inserts an item in a hash table when the key has more than three pointers. Returns 1 if successful; 0 otherwise.
8770<p>
8771
8772<dd> <b>Side Effects</b> None
8773<p>
8774
8775<dd> <b>See Also</b> <code>[cuddHashTableInsert1
8776<a href="cuddAllDet.html#cuddHashTableInsert2">cuddHashTableInsert2</a>
8777<a href="cuddAllDet.html#cuddHashTableInsert3">cuddHashTableInsert3</a>
8778<a href="cuddAllDet.html#cuddHashTableLookup">cuddHashTableLookup</a>
8779</code>
8780
8781<dt><pre>
8782DdNode * <i></i>
8783<a name="cuddHashTableLookup1"><b>cuddHashTableLookup1</b></a>(
8784  DdHashTable * <b>hash</b>, <i></i>
8785  DdNode * <b>f</b> <i></i>
8786)
8787</pre>
8788<dd> Looks up a key consisting of one pointer in a hash table. Returns the value associated to the key if there is an entry for the given key in the table; NULL otherwise. If the entry is present, its reference counter is decremented if not saturated. If the counter reaches 0, the value of the entry is dereferenced, and the entry is returned to the free list.
8789<p>
8790
8791<dd> <b>Side Effects</b> None
8792<p>
8793
8794<dd> <b>See Also</b> <code><a href="cuddAllDet.html#cuddHashTableLookup">cuddHashTableLookup</a>
8795<a href="cuddAllDet.html#cuddHashTableLookup2">cuddHashTableLookup2</a>
8796<a href="cuddAllDet.html#cuddHashTableLookup3">cuddHashTableLookup3</a>
8797<a href="cuddAllDet.html#cuddHashTableInsert1">cuddHashTableInsert1</a>
8798</code>
8799
8800<dt><pre>
8801DdNode * <i></i>
8802<a name="cuddHashTableLookup2"><b>cuddHashTableLookup2</b></a>(
8803  DdHashTable * <b>hash</b>, <i></i>
8804  DdNode * <b>f</b>, <i></i>
8805  DdNode * <b>g</b> <i></i>
8806)
8807</pre>
8808<dd> Looks up a key consisting of two pointer in a hash table. Returns the value associated to the key if there is an entry for the given key in the table; NULL otherwise. If the entry is present, its reference counter is decremented if not saturated. If the counter reaches 0, the value of the entry is dereferenced, and the entry is returned to the free list.
8809<p>
8810
8811<dd> <b>Side Effects</b> None
8812<p>
8813
8814<dd> <b>See Also</b> <code><a href="cuddAllDet.html#cuddHashTableLookup">cuddHashTableLookup</a>
8815<a href="cuddAllDet.html#cuddHashTableLookup1">cuddHashTableLookup1</a>
8816<a href="cuddAllDet.html#cuddHashTableLookup3">cuddHashTableLookup3</a>
8817<a href="cuddAllDet.html#cuddHashTableInsert2">cuddHashTableInsert2</a>
8818</code>
8819
8820<dt><pre>
8821DdNode * <i></i>
8822<a name="cuddHashTableLookup3"><b>cuddHashTableLookup3</b></a>(
8823  DdHashTable * <b>hash</b>, <i></i>
8824  DdNode * <b>f</b>, <i></i>
8825  DdNode * <b>g</b>, <i></i>
8826  DdNode * <b>h</b> <i></i>
8827)
8828</pre>
8829<dd> Looks up a key consisting of three pointers in a hash table. Returns the value associated to the key if there is an entry for the given key in the table; NULL otherwise. If the entry is present, its reference counter is decremented if not saturated. If the counter reaches 0, the value of the entry is dereferenced, and the entry is returned to the free list.
8830<p>
8831
8832<dd> <b>Side Effects</b> None
8833<p>
8834
8835<dd> <b>See Also</b> <code><a href="cuddAllDet.html#cuddHashTableLookup">cuddHashTableLookup</a>
8836<a href="cuddAllDet.html#cuddHashTableLookup1">cuddHashTableLookup1</a>
8837<a href="cuddAllDet.html#cuddHashTableLookup2">cuddHashTableLookup2</a>
8838<a href="cuddAllDet.html#cuddHashTableInsert3">cuddHashTableInsert3</a>
8839</code>
8840
8841<dt><pre>
8842DdNode * <i></i>
8843<a name="cuddHashTableLookup"><b>cuddHashTableLookup</b></a>(
8844  DdHashTable * <b>hash</b>, <i></i>
8845  DdNodePtr * <b>key</b> <i></i>
8846)
8847</pre>
8848<dd> Looks up a key consisting of more than three pointers in a hash table. Returns the value associated to the key if there is an entry for the given key in the table; NULL otherwise. If the entry is present, its reference counter is decremented if not saturated. If the counter reaches 0, the value of the entry is dereferenced, and the entry is returned to the free list.
8849<p>
8850
8851<dd> <b>Side Effects</b> None
8852<p>
8853
8854<dd> <b>See Also</b> <code><a href="cuddAllDet.html#cuddHashTableLookup1">cuddHashTableLookup1</a>
8855<a href="cuddAllDet.html#cuddHashTableLookup2">cuddHashTableLookup2</a>
8856<a href="cuddAllDet.html#cuddHashTableLookup3">cuddHashTableLookup3</a>
8857<a href="cuddAllDet.html#cuddHashTableInsert">cuddHashTableInsert</a>
8858</code>
8859
8860<dt><pre>
8861void <i></i>
8862<a name="cuddHashTableQuit"><b>cuddHashTableQuit</b></a>(
8863  DdHashTable * <b>hash</b> <i></i>
8864)
8865</pre>
8866<dd> Shuts down a hash table, dereferencing all the values.
8867<p>
8868
8869<dd> <b>Side Effects</b> None
8870<p>
8871
8872<dd> <b>See Also</b> <code><a href="cuddAllDet.html#cuddHashTableInit">cuddHashTableInit</a>
8873</code>
8874
8875<dt><pre>
8876int <i></i>
8877<a name="cuddHeapProfile"><b>cuddHeapProfile</b></a>(
8878  DdManager * <b>dd</b> <i></i>
8879)
8880</pre>
8881<dd> Prints to the manager's stdout the number of live nodes for each level of the DD heap that contains at least one live node. It also prints a summary containing: <ul> <li> total number of tables; <li> number of tables with live nodes; <li> table with the largest number of live nodes; <li> number of nodes in that table. </ul> If more than one table contains the maximum number of live nodes, only the one of lowest index is reported. Returns 1 in case of success and 0 otherwise.
8882<p>
8883
8884<dd> <b>Side Effects</b> None
8885<p>
8886
8887<dt><pre>
8888 <i></i>
8889<a name="cuddIZ"><b>cuddIZ</b></a>(
8890   <b>dd</b>, <i></i>
8891   <b>index</b> <i></i>
8892)
8893</pre>
8894<dd> Finds the current position of ZDD variable index in the order. This macro duplicates the functionality of Cudd_ReadPermZdd, but it does not check for out-of-bounds indices and it is more efficient.
8895<p>
8896
8897<dd> <b>Side Effects</b> none
8898<p>
8899
8900<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_ReadPermZdd">Cudd_ReadPermZdd</a>
8901</code>
8902
8903<dt><pre>
8904int <i></i>
8905<a name="cuddInitCache"><b>cuddInitCache</b></a>(
8906  DdManager * <b>unique</b>, <i>unique table</i>
8907  unsigned int  <b>cacheSize</b>, <i>initial size of the cache</i>
8908  unsigned int  <b>maxCacheSize</b> <i>cache size beyond which no resizing occurs</i>
8909)
8910</pre>
8911<dd> Initializes the computed table. It is called by Cudd_Init. Returns 1 in case of success; 0 otherwise.
8912<p>
8913
8914<dd> <b>Side Effects</b> None
8915<p>
8916
8917<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_Init">Cudd_Init</a>
8918</code>
8919
8920<dt><pre>
8921int <i></i>
8922<a name="cuddInitInteract"><b>cuddInitInteract</b></a>(
8923  DdManager * <b>table</b> <i></i>
8924)
8925</pre>
8926<dd> Initializes the interaction matrix. The interaction matrix is implemented as a bit vector storing the upper triangle of the symmetric interaction matrix. The bit vector is kept in an array of long integers. The computation is based on a series of depth-first searches, one for each root of the DAG. Two flags are needed: The local visited flag uses the LSB of the then pointer. The global visited flag uses the LSB of the next pointer. Returns 1 if successful; 0 otherwise.
8927<p>
8928
8929<dd> <b>Side Effects</b> None
8930<p>
8931
8932<dt><pre>
8933int <i></i>
8934<a name="cuddInitLinear"><b>cuddInitLinear</b></a>(
8935  DdManager * <b>table</b> <i></i>
8936)
8937</pre>
8938<dd> Initializes the linear transform matrix. Returns 1 if successful; 0 otherwise.
8939<p>
8940
8941<dd> <b>Side Effects</b> none
8942<p>
8943
8944<dt><pre>
8945DdManager * <i></i>
8946<a name="cuddInitTable"><b>cuddInitTable</b></a>(
8947  unsigned int  <b>numVars</b>, <i>Initial number of BDD variables (and subtables)</i>
8948  unsigned int  <b>numVarsZ</b>, <i>Initial number of ZDD variables (and subtables)</i>
8949  unsigned int  <b>numSlots</b>, <i>Initial size of the BDD subtables</i>
8950  unsigned int  <b>looseUpTo</b> <i>Limit for fast table growth</i>
8951)
8952</pre>
8953<dd> Creates and initializes the unique table. Returns a pointer to the table if successful; NULL otherwise.
8954<p>
8955
8956<dd> <b>Side Effects</b> None
8957<p>
8958
8959<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_Init">Cudd_Init</a>
8960<a href="cuddAllDet.html#cuddFreeTable">cuddFreeTable</a>
8961</code>
8962
8963<dt><pre>
8964int <i></i>
8965<a name="cuddInsertSubtables"><b>cuddInsertSubtables</b></a>(
8966  DdManager * <b>unique</b>, <i></i>
8967  int  <b>n</b>, <i></i>
8968  int  <b>level</b> <i></i>
8969)
8970</pre>
8971<dd> Inserts n new subtables in a unique table at level. The number n should be positive, and level should be an existing level. Returns 1 if successful; 0 otherwise.
8972<p>
8973
8974<dd> <b>Side Effects</b> None
8975<p>
8976
8977<dd> <b>See Also</b> <code><a href="cuddAllDet.html#cuddDestroySubtables">cuddDestroySubtables</a>
8978</code>
8979
8980<dt><pre>
8981 <i></i>
8982<a name="cuddIsConstant"><b>cuddIsConstant</b></a>(
8983   <b>node</b> <i></i>
8984)
8985</pre>
8986<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 cuddIsConstant must be regular.
8987<p>
8988
8989<dd> <b>Side Effects</b> none
8990<p>
8991
8992<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_IsConstant">Cudd_IsConstant</a>
8993</code>
8994
8995<dt><pre>
8996int <i></i>
8997<a name="cuddIsInDeathRow"><b>cuddIsInDeathRow</b></a>(
8998  DdManager * <b>dd</b>, <i></i>
8999  DdNode * <b>f</b> <i></i>
9000)
9001</pre>
9002<dd> Checks whether a node is in the death row. Returns the position of the first occurrence if the node is present; -1 otherwise.
9003<p>
9004
9005<dd> <b>Side Effects</b> None
9006<p>
9007
9008<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_DelayedDerefBdd">Cudd_DelayedDerefBdd</a>
9009<a href="cuddAllDet.html#cuddClearDeathRow">cuddClearDeathRow</a>
9010</code>
9011
9012<dt><pre>
9013 <i></i>
9014<a name="cuddI"><b>cuddI</b></a>(
9015   <b>dd</b>, <i></i>
9016   <b>index</b> <i></i>
9017)
9018</pre>
9019<dd> Finds the current position of variable index in the order. This macro duplicates the functionality of Cudd_ReadPerm, but it does not check for out-of-bounds indices and it is more efficient.
9020<p>
9021
9022<dd> <b>Side Effects</b> none
9023<p>
9024
9025<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_ReadPerm">Cudd_ReadPerm</a>
9026</code>
9027
9028<dt><pre>
9029void <i></i>
9030<a name="cuddLevelQueueDequeue"><b>cuddLevelQueueDequeue</b></a>(
9031  DdLevelQueue * <b>queue</b>, <i></i>
9032  int  <b>level</b> <i></i>
9033)
9034</pre>
9035<dd> Remove an item from the front of a level queue.
9036<p>
9037
9038<dd> <b>Side Effects</b> None
9039<p>
9040
9041<dd> <b>See Also</b> <code><a href="cuddAllDet.html#cuddLevelQueueEnqueue">cuddLevelQueueEnqueue</a>
9042</code>
9043
9044<dt><pre>
9045void * <i></i>
9046<a name="cuddLevelQueueEnqueue"><b>cuddLevelQueueEnqueue</b></a>(
9047  DdLevelQueue * <b>queue</b>, <i>level queue</i>
9048  void * <b>key</b>, <i>key to be enqueued</i>
9049  int  <b>level</b> <i>level at which to insert</i>
9050)
9051</pre>
9052<dd> Inserts a new key in a level queue. A new entry is created in the queue only if the node is not already enqueued. Returns a pointer to the queue item if successful; NULL otherwise.
9053<p>
9054
9055<dd> <b>Side Effects</b> None
9056<p>
9057
9058<dd> <b>See Also</b> <code><a href="cuddAllDet.html#cuddLevelQueueInit">cuddLevelQueueInit</a>
9059<a href="cuddAllDet.html#cuddLevelQueueDequeue">cuddLevelQueueDequeue</a>
9060</code>
9061
9062<dt><pre>
9063DdLevelQueue * <i></i>
9064<a name="cuddLevelQueueInit"><b>cuddLevelQueueInit</b></a>(
9065  int  <b>levels</b>, <i>number of levels</i>
9066  int  <b>itemSize</b>, <i>size of the item</i>
9067  int  <b>numBuckets</b> <i>initial number of hash buckets</i>
9068)
9069</pre>
9070<dd> Initializes a level queue. A level queue is a queue where inserts are based on the levels of the nodes. Within each level the policy is FIFO. Level queues are useful in traversing a BDD top-down. Queue items are kept in a free list when dequeued for efficiency. Returns a pointer to the new queue if successful; NULL otherwise.
9071<p>
9072
9073<dd> <b>Side Effects</b> None
9074<p>
9075
9076<dd> <b>See Also</b> <code><a href="cuddAllDet.html#cuddLevelQueueQuit">cuddLevelQueueQuit</a>
9077<a href="cuddAllDet.html#cuddLevelQueueEnqueue">cuddLevelQueueEnqueue</a>
9078<a href="cuddAllDet.html#cuddLevelQueueDequeue">cuddLevelQueueDequeue</a>
9079</code>
9080
9081<dt><pre>
9082void <i></i>
9083<a name="cuddLevelQueueQuit"><b>cuddLevelQueueQuit</b></a>(
9084  DdLevelQueue * <b>queue</b> <i></i>
9085)
9086</pre>
9087<dd> Shuts down a level queue and releases all the associated memory.
9088<p>
9089
9090<dd> <b>Side Effects</b> None
9091<p>
9092
9093<dd> <b>See Also</b> <code><a href="cuddAllDet.html#cuddLevelQueueInit">cuddLevelQueueInit</a>
9094</code>
9095
9096<dt><pre>
9097int <i></i>
9098<a name="cuddLinearAndSifting"><b>cuddLinearAndSifting</b></a>(
9099  DdManager * <b>table</b>, <i></i>
9100  int  <b>lower</b>, <i></i>
9101  int  <b>upper</b> <i></i>
9102)
9103</pre>
9104<dd> BDD reduction based on combination of sifting and linear transformations. Assumes that no dead nodes are present. <ol> <li> Order all the variables according to the number of entries in each unique table. <li> Sift the variable up and down, remembering each time the total size of the DD heap. At each position, linear transformation of the two adjacent variables is tried and is accepted if it reduces the size of the DD. <li> Select the best permutation. <li> Repeat 3 and 4 for all variables. </ol> Returns 1 if successful; 0 otherwise.
9105<p>
9106
9107<dd> <b>Side Effects</b> None
9108<p>
9109
9110<dt><pre>
9111int <i></i>
9112<a name="cuddLinearInPlace"><b>cuddLinearInPlace</b></a>(
9113  DdManager * <b>table</b>, <i></i>
9114  int  <b>x</b>, <i></i>
9115  int  <b>y</b> <i></i>
9116)
9117</pre>
9118<dd> Linearly combines two adjacent variables. Specifically, replaces the top variable with the exclusive nor of the two variables. It assumes that no dead nodes are present on entry to this procedure. The procedure then guarantees that no dead nodes will be present when it terminates. cuddLinearInPlace assumes that x &lt; y. Returns the number of keys in the table if successful; 0 otherwise.
9119<p>
9120
9121<dd> <b>Side Effects</b> The two subtables corrresponding to variables x and y are modified. The global counters of the unique table are also affected.
9122<p>
9123
9124<dd> <b>See Also</b> <code><a href="cuddAllDet.html#cuddSwapInPlace">cuddSwapInPlace</a>
9125</code>
9126
9127<dt><pre>
9128void <i></i>
9129<a name="cuddLocalCacheClearAll"><b>cuddLocalCacheClearAll</b></a>(
9130  DdManager * <b>manager</b> <i></i>
9131)
9132</pre>
9133<dd> Clears the local caches of a manager. Used before reordering.
9134<p>
9135
9136<dd> <b>Side Effects</b> None
9137<p>
9138
9139<dt><pre>
9140void <i></i>
9141<a name="cuddLocalCacheClearDead"><b>cuddLocalCacheClearDead</b></a>(
9142  DdManager * <b>manager</b> <i></i>
9143)
9144</pre>
9145<dd> Clears the dead entries of the local caches of a manager. Used during garbage collection.
9146<p>
9147
9148<dd> <b>Side Effects</b> None
9149<p>
9150
9151<dt><pre>
9152DdLocalCache * <i></i>
9153<a name="cuddLocalCacheInit"><b>cuddLocalCacheInit</b></a>(
9154  DdManager * <b>manager</b>, <i>manager</i>
9155  unsigned int  <b>keySize</b>, <i>size of the key (number of operands)</i>
9156  unsigned int  <b>cacheSize</b>, <i>Initial size of the cache</i>
9157  unsigned int  <b>maxCacheSize</b> <i>Size of the cache beyond which no resizing occurs</i>
9158)
9159</pre>
9160<dd> Initializes a computed table. Returns a pointer the the new local cache in case of success; NULL otherwise.
9161<p>
9162
9163<dd> <b>Side Effects</b> None
9164<p>
9165
9166<dd> <b>See Also</b> <code><a href="cuddAllDet.html#cuddInitCache">cuddInitCache</a>
9167</code>
9168
9169<dt><pre>
9170void <i></i>
9171<a name="cuddLocalCacheInsert"><b>cuddLocalCacheInsert</b></a>(
9172  DdLocalCache * <b>cache</b>, <i></i>
9173  DdNodePtr * <b>key</b>, <i></i>
9174  DdNode * <b>value</b> <i></i>
9175)
9176</pre>
9177<dd> Inserts a result in a local cache.
9178<p>
9179
9180<dd> <b>Side Effects</b> None
9181<p>
9182
9183<dt><pre>
9184DdNode * <i></i>
9185<a name="cuddLocalCacheLookup"><b>cuddLocalCacheLookup</b></a>(
9186  DdLocalCache * <b>cache</b>, <i></i>
9187  DdNodePtr * <b>key</b> <i></i>
9188)
9189</pre>
9190<dd> Looks up in a local cache. Returns the result if found; it returns NULL if no result is found.
9191<p>
9192
9193<dd> <b>Side Effects</b> None
9194<p>
9195
9196<dt><pre>
9197int <i></i>
9198<a name="cuddLocalCacheProfile"><b>cuddLocalCacheProfile</b></a>(
9199  DdLocalCache * <b>cache</b> <i></i>
9200)
9201</pre>
9202<dd> Computes and prints a profile of a local cache usage. Returns 1 if successful; 0 otherwise.
9203<p>
9204
9205<dd> <b>Side Effects</b> None
9206<p>
9207
9208<dt><pre>
9209void <i></i>
9210<a name="cuddLocalCacheQuit"><b>cuddLocalCacheQuit</b></a>(
9211  DdLocalCache * <b>cache</b> <i>cache to be shut down</i>
9212)
9213</pre>
9214<dd> Initializes the computed table. It is called by Cudd_Init. Returns a pointer the the new local cache in case of success; NULL otherwise.
9215<p>
9216
9217<dd> <b>Side Effects</b> None
9218<p>
9219
9220<dd> <b>See Also</b> <code><a href="cuddAllDet.html#cuddLocalCacheInit">cuddLocalCacheInit</a>
9221</code>
9222
9223<dt><pre>
9224DdNode  * <i></i>
9225<a name="cuddMakeBddFromZddCover"><b>cuddMakeBddFromZddCover</b></a>(
9226  DdManager * <b>dd</b>, <i></i>
9227  DdNode * <b>node</b> <i></i>
9228)
9229</pre>
9230<dd> Converts a ZDD cover to a BDD graph. If successful, it returns a BDD node, otherwise it returns NULL. It is a recursive algorithm as the following. First computes 3 cofactors of a ZDD cover; f1, f0 and fd. Second, compute BDDs(b1, b0 and bd) of f1, f0 and fd. Third, compute T=b1+bd and E=b0+bd. Fourth, compute ITE(v,T,E) where v is the variable which has the index of the top node of the ZDD cover. In this case, since the index of v can be larger than either one of T or one of E, cuddUniqueInterIVO is called, here IVO stands for independent variable ordering.
9231<p>
9232
9233<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_MakeBddFromZddCover">Cudd_MakeBddFromZddCover</a>
9234</code>
9235
9236<dt><pre>
9237int <i></i>
9238<a name="cuddNextHigh"><b>cuddNextHigh</b></a>(
9239  DdManager * <b>table</b>, <i></i>
9240  int  <b>x</b> <i></i>
9241)
9242</pre>
9243<dd> Finds the next subtable with a larger index. Returns the index.
9244<p>
9245
9246<dd> <b>Side Effects</b> None
9247<p>
9248
9249<dd> <b>See Also</b> <code><a href="cuddAllDet.html#cuddNextLow">cuddNextLow</a>
9250</code>
9251
9252<dt><pre>
9253int <i></i>
9254<a name="cuddNextLow"><b>cuddNextLow</b></a>(
9255  DdManager * <b>table</b>, <i></i>
9256  int  <b>x</b> <i></i>
9257)
9258</pre>
9259<dd> Finds the next subtable with a smaller index. Returns the index.
9260<p>
9261
9262<dd> <b>Side Effects</b> None
9263<p>
9264
9265<dd> <b>See Also</b> <code><a href="cuddAllDet.html#cuddNextHigh">cuddNextHigh</a>
9266</code>
9267
9268<dt><pre>
9269DdNodePtr * <i></i>
9270<a name="cuddNodeArray"><b>cuddNodeArray</b></a>(
9271  DdNode * <b>f</b>, <i></i>
9272  int * <b>n</b> <i></i>
9273)
9274</pre>
9275<dd> Traverses the DD f and collects all its nodes in an array. The caller should free the array returned by cuddNodeArray. Returns a pointer to the array of nodes in case of success; NULL otherwise. The nodes are collected in reverse topological order, so that a node is always preceded in the array by all its descendants.
9276<p>
9277
9278<dd> <b>Side Effects</b> The number of nodes is returned as a side effect.
9279<p>
9280
9281<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_FirstNode">Cudd_FirstNode</a>
9282</code>
9283
9284<dt><pre>
9285void <i></i>
9286<a name="cuddPrintNode"><b>cuddPrintNode</b></a>(
9287  DdNode * <b>f</b>, <i></i>
9288  FILE * <b>fp</b> <i></i>
9289)
9290</pre>
9291<dd> Prints out information on a node.
9292<p>
9293
9294<dd> <b>Side Effects</b> None
9295<p>
9296
9297<dt><pre>
9298void <i></i>
9299<a name="cuddPrintVarGroups"><b>cuddPrintVarGroups</b></a>(
9300  DdManager * <b>dd</b>, <i>manager</i>
9301  MtrNode * <b>root</b>, <i>root of the group tree</i>
9302  int  <b>zdd</b>, <i>0: BDD; 1: ZDD</i>
9303  int  <b>silent</b> <i>flag to check tree syntax only</i>
9304)
9305</pre>
9306<dd> Prints the variable groups as a parenthesized list. For each group the level range that it represents is printed. After each group, the group's flags are printed, preceded by a `|'. For each flag (except MTR_TERMINAL) a character is printed. <ul> <li>F: MTR_FIXED <li>N: MTR_NEWNODE <li>S: MTR_SOFT </ul> The second argument, silent, if different from 0, causes Cudd_PrintVarGroups to only check the syntax of the group tree.
9307<p>
9308
9309<dd> <b>Side Effects</b> None
9310<p>
9311
9312<dt><pre>
9313int <i></i>
9314<a name="cuddP"><b>cuddP</b></a>(
9315  DdManager * <b>dd</b>, <i></i>
9316  DdNode * <b>f</b> <i></i>
9317)
9318</pre>
9319<dd> Prints a DD to the standard output. One line per node is printed. Returns 1 if successful; 0 otherwise.
9320<p>
9321
9322<dd> <b>Side Effects</b> None
9323<p>
9324
9325<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_PrintDebug">Cudd_PrintDebug</a>
9326</code>
9327
9328<dt><pre>
9329void <i></i>
9330<a name="cuddReclaimZdd"><b>cuddReclaimZdd</b></a>(
9331  DdManager * <b>table</b>, <i></i>
9332  DdNode * <b>n</b> <i></i>
9333)
9334</pre>
9335<dd> Brings children of a dead ZDD node back.
9336<p>
9337
9338<dd> <b>Side Effects</b> None
9339<p>
9340
9341<dd> <b>See Also</b> <code><a href="cuddAllDet.html#cuddReclaim">cuddReclaim</a>
9342</code>
9343
9344<dt><pre>
9345void <i></i>
9346<a name="cuddReclaim"><b>cuddReclaim</b></a>(
9347  DdManager * <b>table</b>, <i></i>
9348  DdNode * <b>n</b> <i></i>
9349)
9350</pre>
9351<dd> Brings children of a dead node back.
9352<p>
9353
9354<dd> <b>Side Effects</b> None
9355<p>
9356
9357<dd> <b>See Also</b> <code><a href="cuddAllDet.html#cuddReclaimZdd">cuddReclaimZdd</a>
9358</code>
9359
9360<dt><pre>
9361 <i></i>
9362<a name="cuddRef"><b>cuddRef</b></a>(
9363   <b>n</b> <i></i>
9364)
9365</pre>
9366<dd> Increases the reference count of a node, if it is not saturated. This being a macro, it is faster than Cudd_Ref, but it cannot be used in constructs like cuddRef(a = b()).
9367<p>
9368
9369<dd> <b>Side Effects</b> none
9370<p>
9371
9372<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_Ref">Cudd_Ref</a>
9373</code>
9374
9375<dt><pre>
9376void <i></i>
9377<a name="cuddRehash"><b>cuddRehash</b></a>(
9378  DdManager * <b>unique</b>, <i></i>
9379  int  <b>i</b> <i></i>
9380)
9381</pre>
9382<dd> Doubles the size of a unique subtable and rehashes its contents.
9383<p>
9384
9385<dd> <b>Side Effects</b> None
9386<p>
9387
9388<dt><pre>
9389DdNode * <i></i>
9390<a name="cuddRemapUnderApprox"><b>cuddRemapUnderApprox</b></a>(
9391  DdManager * <b>dd</b>, <i>DD manager</i>
9392  DdNode * <b>f</b>, <i>current DD</i>
9393  int  <b>numVars</b>, <i>maximum number of variables</i>
9394  int  <b>threshold</b>, <i>threshold under which approximation stops</i>
9395  double  <b>quality</b> <i>minimum improvement for accepted changes</i>
9396)
9397</pre>
9398<dd> Applies the remapping underappoximation algorithm. Proceeds in three phases: <ul> <li> collect information on each node in the BDD; this is done via DFS. <li> traverse the BDD in top-down fashion and compute for each node whether remapping increases density. <li> traverse the BDD via DFS and actually perform the elimination. </ul> Returns the approximated BDD if successful; NULL otherwise.
9399<p>
9400
9401<dd> <b>Side Effects</b> None
9402<p>
9403
9404<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_RemapUnderApprox">Cudd_RemapUnderApprox</a>
9405</code>
9406
9407<dt><pre>
9408int <i></i>
9409<a name="cuddResizeLinear"><b>cuddResizeLinear</b></a>(
9410  DdManager * <b>table</b> <i></i>
9411)
9412</pre>
9413<dd> Resizes the linear transform matrix. Returns 1 if successful; 0 otherwise.
9414<p>
9415
9416<dd> <b>Side Effects</b> none
9417<p>
9418
9419<dt><pre>
9420int <i></i>
9421<a name="cuddResizeTableZdd"><b>cuddResizeTableZdd</b></a>(
9422  DdManager * <b>unique</b>, <i></i>
9423  int  <b>index</b> <i></i>
9424)
9425</pre>
9426<dd> Increases the number of ZDD subtables in a unique table so that it meets or exceeds index. When new ZDD variables are created, it is possible to preserve the functions unchanged, or it is possible to preserve the covers unchanged, but not both. cuddResizeTableZdd preserves the covers. Returns 1 if successful; 0 otherwise.
9427<p>
9428
9429<dd> <b>Side Effects</b> None
9430<p>
9431
9432<dd> <b>See Also</b> <code><a href="ddAllDet.html#ddResizeTable">ddResizeTable</a>
9433</code>
9434
9435<dt><pre>
9436 <i></i>
9437<a name="cuddSatDec"><b>cuddSatDec</b></a>(
9438   <b>x</b> <i></i>
9439)
9440</pre>
9441<dd> Saturating decrement operator.
9442<p>
9443
9444<dd> <b>Side Effects</b> none
9445<p>
9446
9447<dd> <b>See Also</b> <code><a href="cuddAllDet.html#cuddSatInc">cuddSatInc</a>
9448</code>
9449
9450<dt><pre>
9451 <i></i>
9452<a name="cuddSatInc"><b>cuddSatInc</b></a>(
9453   <b>x</b> <i></i>
9454)
9455</pre>
9456<dd> Saturating increment operator.
9457<p>
9458
9459<dd> <b>Side Effects</b> none
9460<p>
9461
9462<dd> <b>See Also</b> <code><a href="cuddAllDet.html#cuddSatDec">cuddSatDec</a>
9463</code>
9464
9465<dt><pre>
9466void <i></i>
9467<a name="cuddSetInteract"><b>cuddSetInteract</b></a>(
9468  DdManager * <b>table</b>, <i></i>
9469  int  <b>x</b>, <i></i>
9470  int  <b>y</b> <i></i>
9471)
9472</pre>
9473<dd> Given a pair of variables 0 <= x < y < table->size, sets the corresponding bit of the interaction matrix to 1.
9474<p>
9475
9476<dd> <b>Side Effects</b> None
9477<p>
9478
9479<dt><pre>
9480void <i></i>
9481<a name="cuddShrinkDeathRow"><b>cuddShrinkDeathRow</b></a>(
9482  DdManager * <b>table</b> <i></i>
9483)
9484</pre>
9485<dd> Shrinks the death row by a factor of four.
9486<p>
9487
9488<dd> <b>Side Effects</b> None
9489<p>
9490
9491<dd> <b>See Also</b> <code><a href="cuddAllDet.html#cuddClearDeathRow">cuddClearDeathRow</a>
9492</code>
9493
9494<dt><pre>
9495void <i></i>
9496<a name="cuddShrinkSubtable"><b>cuddShrinkSubtable</b></a>(
9497  DdManager * <b>unique</b>, <i></i>
9498  int  <b>i</b> <i></i>
9499)
9500</pre>
9501<dd> Shrinks a subtable.
9502<p>
9503
9504<dd> <b>Side Effects</b> None
9505<p>
9506
9507<dd> <b>See Also</b> <code><a href="cuddAllDet.html#cuddRehash">cuddRehash</a>
9508</code>
9509
9510<dt><pre>
9511int <i></i>
9512<a name="cuddSifting"><b>cuddSifting</b></a>(
9513  DdManager * <b>table</b>, <i></i>
9514  int  <b>lower</b>, <i></i>
9515  int  <b>upper</b> <i></i>
9516)
9517</pre>
9518<dd> Implementation of Rudell's sifting algorithm. Assumes that no dead nodes are present. <ol> <li> Order all the variables according to the number of entries in each unique table. <li> Sift the variable up and down, remembering each time the total size of the DD heap. <li> Select the best permutation. <li> Repeat 3 and 4 for all variables. </ol> Returns 1 if successful; 0 otherwise.
9519<p>
9520
9521<dd> <b>Side Effects</b> None
9522<p>
9523
9524<dt><pre>
9525void <i></i>
9526<a name="cuddSlowTableGrowth"><b>cuddSlowTableGrowth</b></a>(
9527  DdManager * <b>unique</b> <i></i>
9528)
9529</pre>
9530<dd> Adjusts parameters of a table to slow down its growth.
9531<p>
9532
9533<dd> <b>Side Effects</b> None
9534<p>
9535
9536<dt><pre>
9537DdNode * <i></i>
9538<a name="cuddSolveEqnRecur"><b>cuddSolveEqnRecur</b></a>(
9539  DdManager * <b>bdd</b>, <i></i>
9540  DdNode * <b>F</b>, <i>the left-hand side of the equation</i>
9541  DdNode * <b>Y</b>, <i>the cube of remaining y variables</i>
9542  DdNode ** <b>G</b>, <i>the array of solutions</i>
9543  int  <b>n</b>, <i>number of unknowns</i>
9544  int * <b>yIndex</b>, <i>array holding the y variable indices</i>
9545  int  <b>i</b> <i>level of recursion</i>
9546)
9547</pre>
9548<dd> Implements the recursive step of Cudd_SolveEqn. Returns NULL if the intermediate solution blows up or reordering occurs. The parametric solutions are stored in the array G.
9549<p>
9550
9551<dd> <b>Side Effects</b> none
9552<p>
9553
9554<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_SolveEqn">Cudd_SolveEqn</a>
9555<a href="cuddAllDet.html#Cudd_VerifySol">Cudd_VerifySol</a>
9556</code>
9557
9558<dt><pre>
9559DdNode* <i></i>
9560<a name="cuddSplitSetRecur"><b>cuddSplitSetRecur</b></a>(
9561  DdManager * <b>manager</b>, <i></i>
9562  st_table * <b>mtable</b>, <i></i>
9563  int * <b>varSeen</b>, <i></i>
9564  DdNode * <b>p</b>, <i></i>
9565  double  <b>n</b>, <i></i>
9566  double  <b>max</b>, <i></i>
9567  int  <b>index</b> <i></i>
9568)
9569</pre>
9570<dd> Implements the recursive step of Cudd_SplitSet. The procedure recursively traverses the BDD and checks to see if any node satisfies the minterm requirements as specified by 'n'. At any node X, n is compared to the number of minterms in the onset of X's children. If either of the child nodes have exactly n minterms, then that node is returned; else, if n is greater than the onset of one of the child nodes, that node is retained and the difference in the number of minterms is extracted from the other child. In case n minterms can be extracted from constant 1, the algorithm returns the result with at most log(n) nodes.
9571<p>
9572
9573<dd> <b>Side Effects</b> The array 'varSeen' is updated at every recursive call to set the variables traversed by the procedure.
9574<p>
9575
9576<dt><pre>
9577enum st_retval <i></i>
9578<a name="cuddStCountfree"><b>cuddStCountfree</b></a>(
9579  char * <b>key</b>, <i></i>
9580  char * <b>value</b>, <i></i>
9581  char * <b>arg</b> <i></i>
9582)
9583</pre>
9584<dd> Frees the memory used to store the minterm counts recorded in the visited table. Returns ST_CONTINUE.
9585<p>
9586
9587<dd> <b>Side Effects</b> None
9588<p>
9589
9590<dt><pre>
9591DdNode * <i></i>
9592<a name="cuddSubsetHeavyBranch"><b>cuddSubsetHeavyBranch</b></a>(
9593  DdManager * <b>dd</b>, <i>DD manager</i>
9594  DdNode * <b>f</b>, <i>current DD</i>
9595  int  <b>numVars</b>, <i>maximum number of variables</i>
9596  int  <b>threshold</b> <i>threshold size for the subset</i>
9597)
9598</pre>
9599<dd> Here a subset BDD is built by throwing away one of the children. Starting at root, annotate each node with the number of minterms (in terms of the total number of variables specified - numVars), number of nodes taken by the DAG rooted at this node and number of additional nodes taken by the child that has the lesser minterms. The child with the lower number of minterms is thrown away and a dyanmic count of the nodes of the subset is kept. Once the threshold is reached the subset is returned to the calling procedure.
9600<p>
9601
9602<dd> <b>Side Effects</b> None
9603<p>
9604
9605<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_SubsetHeavyBranch">Cudd_SubsetHeavyBranch</a>
9606</code>
9607
9608<dt><pre>
9609DdNode * <i></i>
9610<a name="cuddSubsetShortPaths"><b>cuddSubsetShortPaths</b></a>(
9611  DdManager * <b>dd</b>, <i>DD manager</i>
9612  DdNode * <b>f</b>, <i>function to be subset</i>
9613  int  <b>numVars</b>, <i>total number of variables in consideration</i>
9614  int  <b>threshold</b>, <i>maximum number of nodes allowed in the subset</i>
9615  int  <b>hardlimit</b> <i>flag determining whether thershold should be respected strictly</i>
9616)
9617</pre>
9618<dd> The outermost procedure to return a subset of the given BDD with the largest cubes. The path lengths are calculated, the maximum allowable path length is determined and the number of nodes of this path length that can be used to build a subset. If the threshold is larger than the size of the original BDD, the original BDD is returned.
9619<p>
9620
9621<dd> <b>Side Effects</b> None
9622<p>
9623
9624<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_SubsetShortPaths">Cudd_SubsetShortPaths</a>
9625</code>
9626
9627<dt><pre>
9628int <i></i>
9629<a name="cuddSwapInPlace"><b>cuddSwapInPlace</b></a>(
9630  DdManager * <b>table</b>, <i></i>
9631  int  <b>x</b>, <i></i>
9632  int  <b>y</b> <i></i>
9633)
9634</pre>
9635<dd> Swaps two adjacent variables. It assumes that no dead nodes are present on entry to this procedure. The procedure then guarantees that no dead nodes will be present when it terminates. cuddSwapInPlace assumes that x &lt; y. Returns the number of keys in the table if successful; 0 otherwise.
9636<p>
9637
9638<dd> <b>Side Effects</b> None
9639<p>
9640
9641<dt><pre>
9642int <i></i>
9643<a name="cuddSwapping"><b>cuddSwapping</b></a>(
9644  DdManager * <b>table</b>, <i></i>
9645  int  <b>lower</b>, <i></i>
9646  int  <b>upper</b>, <i></i>
9647  Cudd_ReorderingType  <b>heuristic</b> <i></i>
9648)
9649</pre>
9650<dd> Implementation of Plessier's algorithm that reorders variables by a sequence of (non-adjacent) swaps. <ol> <li> Select two variables (RANDOM or HEURISTIC). <li> Permute these variables. <li> If the nodes have decreased accept the permutation. <li> Otherwise reconstruct the original heap. <li> Loop. </ol> Returns 1 in case of success; 0 otherwise.
9651<p>
9652
9653<dd> <b>Side Effects</b> None
9654<p>
9655
9656<dt><pre>
9657int <i></i>
9658<a name="cuddSymmCheck"><b>cuddSymmCheck</b></a>(
9659  DdManager * <b>table</b>, <i></i>
9660  int  <b>x</b>, <i></i>
9661  int  <b>y</b> <i></i>
9662)
9663</pre>
9664<dd> Checks for symmetry of x and y. Ignores projection functions, unless they are isolated. Returns 1 in case of symmetry; 0 otherwise.
9665<p>
9666
9667<dd> <b>Side Effects</b> None
9668<p>
9669
9670<dt><pre>
9671int <i></i>
9672<a name="cuddSymmSiftingConv"><b>cuddSymmSiftingConv</b></a>(
9673  DdManager * <b>table</b>, <i></i>
9674  int  <b>lower</b>, <i></i>
9675  int  <b>upper</b> <i></i>
9676)
9677</pre>
9678<dd> Symmetric sifting to convergence algorithm. Assumes that no dead nodes are present. <ol> <li> Order all the variables according to the number of entries in each unique subtable. <li> Sift the variable up and down, remembering each time the total size of the DD heap and grouping variables that are symmetric. <li> Select the best permutation. <li> Repeat 3 and 4 for all variables. <li> Repeat 1-4 until no further improvement. </ol> Returns 1 plus the number of symmetric variables if successful; 0 otherwise.
9679<p>
9680
9681<dd> <b>Side Effects</b> None
9682<p>
9683
9684<dd> <b>See Also</b> <code><a href="cuddAllDet.html#cuddSymmSifting">cuddSymmSifting</a>
9685</code>
9686
9687<dt><pre>
9688int <i></i>
9689<a name="cuddSymmSifting"><b>cuddSymmSifting</b></a>(
9690  DdManager * <b>table</b>, <i></i>
9691  int  <b>lower</b>, <i></i>
9692  int  <b>upper</b> <i></i>
9693)
9694</pre>
9695<dd> Symmetric sifting algorithm. Assumes that no dead nodes are present. <ol> <li> Order all the variables according to the number of entries in each unique subtable. <li> Sift the variable up and down, remembering each time the total size of the DD heap and grouping variables that are symmetric. <li> Select the best permutation. <li> Repeat 3 and 4 for all variables. </ol> Returns 1 plus the number of symmetric variables if successful; 0 otherwise.
9696<p>
9697
9698<dd> <b>Side Effects</b> None
9699<p>
9700
9701<dd> <b>See Also</b> <code><a href="cuddAllDet.html#cuddSymmSiftingConv">cuddSymmSiftingConv</a>
9702</code>
9703
9704<dt><pre>
9705int <i></i>
9706<a name="cuddTestInteract"><b>cuddTestInteract</b></a>(
9707  DdManager * <b>table</b>, <i></i>
9708  int  <b>x</b>, <i></i>
9709  int  <b>y</b> <i></i>
9710)
9711</pre>
9712<dd> Given a pair of variables 0 <= x < y < table->size, tests whether the corresponding bit of the interaction matrix is 1. Returns the value of the bit.
9713<p>
9714
9715<dd> <b>Side Effects</b> None
9716<p>
9717
9718<dt><pre>
9719int <i></i>
9720<a name="cuddTimesInDeathRow"><b>cuddTimesInDeathRow</b></a>(
9721  DdManager * <b>dd</b>, <i></i>
9722  DdNode * <b>f</b> <i></i>
9723)
9724</pre>
9725<dd> Counts how many times a node is in the death row.
9726<p>
9727
9728<dd> <b>Side Effects</b> None
9729<p>
9730
9731<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_DelayedDerefBdd">Cudd_DelayedDerefBdd</a>
9732<a href="cuddAllDet.html#cuddClearDeathRow">cuddClearDeathRow</a>
9733<a href="cuddAllDet.html#cuddIsInDeathRow">cuddIsInDeathRow</a>
9734</code>
9735
9736<dt><pre>
9737int <i></i>
9738<a name="cuddTreeSifting"><b>cuddTreeSifting</b></a>(
9739  DdManager * <b>table</b>, <i>DD table</i>
9740  Cudd_ReorderingType  <b>method</b> <i>reordering method for the groups of leaves</i>
9741)
9742</pre>
9743<dd> Tree sifting algorithm. Assumes that a tree representing a group hierarchy is passed as a parameter. It then reorders each group in postorder fashion by calling ddTreeSiftingAux. Assumes that no dead nodes are present. Returns 1 if successful; 0 otherwise.
9744<p>
9745
9746<dd> <b>Side Effects</b> None
9747<p>
9748
9749<dt><pre>
9750 <i></i>
9751<a name="cuddT"><b>cuddT</b></a>(
9752   <b>node</b> <i></i>
9753)
9754</pre>
9755<dd> Returns the then child of an internal node. If <code>node</code> is a constant node, the result is unpredictable. The pointer passed to cuddT must be regular.
9756<p>
9757
9758<dd> <b>Side Effects</b> none
9759<p>
9760
9761<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_T">Cudd_T</a>
9762</code>
9763
9764<dt><pre>
9765DdNode * <i></i>
9766<a name="cuddUnderApprox"><b>cuddUnderApprox</b></a>(
9767  DdManager * <b>dd</b>, <i>DD manager</i>
9768  DdNode * <b>f</b>, <i>current DD</i>
9769  int  <b>numVars</b>, <i>maximum number of variables</i>
9770  int  <b>threshold</b>, <i>threshold under which approximation stops</i>
9771  int  <b>safe</b>, <i>enforce safe approximation</i>
9772  double  <b>quality</b> <i>minimum improvement for accepted changes</i>
9773)
9774</pre>
9775<dd> Applies Tom Shiple's underappoximation algorithm. Proceeds in three phases: <ul> <li> collect information on each node in the BDD; this is done via DFS. <li> traverse the BDD in top-down fashion and compute for each node whether its elimination increases density. <li> traverse the BDD via DFS and actually perform the elimination. </ul> Returns the approximated BDD if successful; NULL otherwise.
9776<p>
9777
9778<dd> <b>Side Effects</b> None
9779<p>
9780
9781<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_UnderApprox">Cudd_UnderApprox</a>
9782</code>
9783
9784<dt><pre>
9785DdNode * <i></i>
9786<a name="cuddUniqueConst"><b>cuddUniqueConst</b></a>(
9787  DdManager * <b>unique</b>, <i></i>
9788  CUDD_VALUE_TYPE  <b>value</b> <i></i>
9789)
9790</pre>
9791<dd> Checks the unique table for the existence of a constant node. If it does not exist, it creates a new one. Does not modify the reference count of whatever is returned. A newly created internal node comes back with a reference count 0. Returns a pointer to the new node.
9792<p>
9793
9794<dd> <b>Side Effects</b> None
9795<p>
9796
9797<dt><pre>
9798DdNode * <i></i>
9799<a name="cuddUniqueInterIVO"><b>cuddUniqueInterIVO</b></a>(
9800  DdManager * <b>unique</b>, <i></i>
9801  int  <b>index</b>, <i></i>
9802  DdNode * <b>T</b>, <i></i>
9803  DdNode * <b>E</b> <i></i>
9804)
9805</pre>
9806<dd> Wrapper for cuddUniqueInter that is independent of variable ordering (IVO). This function does not require parameter index to precede the indices of the top nodes of T and E in the variable order. Returns a pointer to the result node under normal conditions; NULL if reordering occurred or memory was exhausted.
9807<p>
9808
9809<dd> <b>Side Effects</b> None
9810<p>
9811
9812<dd> <b>See Also</b> <code><a href="cuddAllDet.html#cuddUniqueInter">cuddUniqueInter</a>
9813<a href="cuddAllDet.html#Cudd_MakeBddFromZddCover">Cudd_MakeBddFromZddCover</a>
9814</code>
9815
9816<dt><pre>
9817DdNode * <i></i>
9818<a name="cuddUniqueInterZdd"><b>cuddUniqueInterZdd</b></a>(
9819  DdManager * <b>unique</b>, <i></i>
9820  int  <b>index</b>, <i></i>
9821  DdNode * <b>T</b>, <i></i>
9822  DdNode * <b>E</b> <i></i>
9823)
9824</pre>
9825<dd> Checks the unique table for the existence of an internal ZDD node. If it does not exist, it creates a new one. Does not modify the reference count of whatever is returned. A newly created internal node comes back with a reference count 0. For a newly created node, increments the reference counts of what T and E point to. Returns a pointer to the new node if successful; NULL if memory is exhausted or if reordering took place.
9826<p>
9827
9828<dd> <b>Side Effects</b> None
9829<p>
9830
9831<dd> <b>See Also</b> <code><a href="cuddAllDet.html#cuddUniqueInter">cuddUniqueInter</a>
9832</code>
9833
9834<dt><pre>
9835DdNode * <i></i>
9836<a name="cuddUniqueInter"><b>cuddUniqueInter</b></a>(
9837  DdManager * <b>unique</b>, <i></i>
9838  int  <b>index</b>, <i></i>
9839  DdNode * <b>T</b>, <i></i>
9840  DdNode * <b>E</b> <i></i>
9841)
9842</pre>
9843<dd> Checks the unique table for the existence of an internal node. If it does not exist, it creates a new one. Does not modify the reference count of whatever is returned. A newly created internal node comes back with a reference count 0. For a newly created node, increments the reference counts of what T and E point to. Returns a pointer to the new node if successful; NULL if memory is exhausted or if reordering took place.
9844<p>
9845
9846<dd> <b>Side Effects</b> None
9847<p>
9848
9849<dd> <b>See Also</b> <code><a href="cuddAllDet.html#cuddUniqueInterZdd">cuddUniqueInterZdd</a>
9850</code>
9851
9852<dt><pre>
9853void <i></i>
9854<a name="cuddUpdateInteractionMatrix"><b>cuddUpdateInteractionMatrix</b></a>(
9855  DdManager * <b>table</b>, <i></i>
9856  int  <b>xindex</b>, <i></i>
9857  int  <b>yindex</b> <i></i>
9858)
9859</pre>
9860<dd> Updates the interaction matrix.
9861<p>
9862
9863<dd> <b>Side Effects</b> none
9864<p>
9865
9866<dt><pre>
9867DdNode * <i></i>
9868<a name="cuddVerifySol"><b>cuddVerifySol</b></a>(
9869  DdManager * <b>bdd</b>, <i></i>
9870  DdNode * <b>F</b>, <i>the left-hand side of the equation</i>
9871  DdNode ** <b>G</b>, <i>the array of solutions</i>
9872  int * <b>yIndex</b>, <i>array holding the y variable indices</i>
9873  int  <b>n</b> <i>number of unknowns</i>
9874)
9875</pre>
9876<dd> Implements the recursive step of Cudd_VerifySol.
9877<p>
9878
9879<dd> <b>Side Effects</b> none
9880<p>
9881
9882<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_VerifySol">Cudd_VerifySol</a>
9883</code>
9884
9885<dt><pre>
9886 <i></i>
9887<a name="cuddV"><b>cuddV</b></a>(
9888   <b>node</b> <i></i>
9889)
9890</pre>
9891<dd> Returns the value of a constant node. If <code>node</code> is an internal node, the result is unpredictable. The pointer passed to cuddV must be regular.
9892<p>
9893
9894<dd> <b>Side Effects</b> none
9895<p>
9896
9897<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_V">Cudd_V</a>
9898</code>
9899
9900<dt><pre>
9901int <i></i>
9902<a name="cuddWindowReorder"><b>cuddWindowReorder</b></a>(
9903  DdManager * <b>table</b>, <i>DD table</i>
9904  int  <b>low</b>, <i>lowest index to reorder</i>
9905  int  <b>high</b>, <i>highest index to reorder</i>
9906  Cudd_ReorderingType  <b>submethod</b> <i>window reordering option</i>
9907)
9908</pre>
9909<dd> Reorders by applying the method of the sliding window. Tries all possible permutations to the variables in a window that slides from low to high. The size of the window is determined by submethod. Assumes that no dead nodes are present. Returns 1 in case of success; 0 otherwise.
9910<p>
9911
9912<dd> <b>Side Effects</b> None
9913<p>
9914
9915<dt><pre>
9916int <i></i>
9917<a name="cuddZddAlignToBdd"><b>cuddZddAlignToBdd</b></a>(
9918  DdManager * <b>table</b> <i>DD manager</i>
9919)
9920</pre>
9921<dd> Reorders ZDD variables according to the order of the BDD variables. This function can be called at the end of BDD reordering to insure that the order of the ZDD variables is consistent with the order of the BDD variables. The number of ZDD variables must be a multiple of the number of BDD variables. Let <code>M</code> be the ratio of the two numbers. cuddZddAlignToBdd then considers the ZDD variables from <code>M*i</code> to <code>(M+1)*i-1</code> as corresponding to BDD variable <code>i</code>. This function should be normally called from Cudd_ReduceHeap, which clears the cache. Returns 1 in case of success; 0 otherwise.
9922<p>
9923
9924<dd> <b>Side Effects</b> Changes the ZDD variable order for all diagrams and performs garbage collection of the ZDD unique table.
9925<p>
9926
9927<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_zddShuffleHeap">Cudd_zddShuffleHeap</a>
9928<a href="cuddAllDet.html#Cudd_ReduceHeap">Cudd_ReduceHeap</a>
9929</code>
9930
9931<dt><pre>
9932DdNode * <i></i>
9933<a name="cuddZddChangeAux"><b>cuddZddChangeAux</b></a>(
9934  DdManager * <b>zdd</b>, <i></i>
9935  DdNode * <b>P</b>, <i></i>
9936  DdNode * <b>zvar</b> <i></i>
9937)
9938</pre>
9939<dd> Performs the recursive step of Cudd_zddChange.
9940<p>
9941
9942<dd> <b>Side Effects</b> None
9943<p>
9944
9945<dt><pre>
9946DdNode * <i></i>
9947<a name="cuddZddChange"><b>cuddZddChange</b></a>(
9948  DdManager * <b>dd</b>, <i></i>
9949  DdNode * <b>P</b>, <i></i>
9950  int  <b>var</b> <i></i>
9951)
9952</pre>
9953<dd> Substitutes a variable with its complement in a ZDD. returns a pointer to the result if successful; NULL otherwise. cuddZddChange performs the same function as Cudd_zddChange, but does not restart if reordering has taken place. Therefore it can be called from within a recursive procedure.
9954<p>
9955
9956<dd> <b>Side Effects</b> None
9957<p>
9958
9959<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_zddChange">Cudd_zddChange</a>
9960</code>
9961
9962<dt><pre>
9963DdNode  * <i></i>
9964<a name="cuddZddComplement"><b>cuddZddComplement</b></a>(
9965  DdManager * <b>dd</b>, <i></i>
9966  DdNode * <b>node</b> <i></i>
9967)
9968</pre>
9969<dd> Computes the complement of a ZDD node. So far, since we couldn't find a direct way to get the complement of a ZDD cover, we first convert a ZDD cover to a BDD, then make the complement of the ZDD cover from the complement of the BDD node by using ISOP.
9970<p>
9971
9972<dd> <b>Side Effects</b> The result depends on current variable order.
9973<p>
9974
9975<dt><pre>
9976DdNode * <i></i>
9977<a name="cuddZddDiff"><b>cuddZddDiff</b></a>(
9978  DdManager * <b>zdd</b>, <i></i>
9979  DdNode * <b>P</b>, <i></i>
9980  DdNode * <b>Q</b> <i></i>
9981)
9982</pre>
9983<dd> Performs the recursive step of Cudd_zddDiff.
9984<p>
9985
9986<dd> <b>Side Effects</b> None
9987<p>
9988
9989<dt><pre>
9990DdNode  * <i></i>
9991<a name="cuddZddDivideF"><b>cuddZddDivideF</b></a>(
9992  DdManager * <b>dd</b>, <i></i>
9993  DdNode * <b>f</b>, <i></i>
9994  DdNode * <b>g</b> <i></i>
9995)
9996</pre>
9997<dd> Performs the recursive step of Cudd_zddDivideF.
9998<p>
9999
10000<dd> <b>Side Effects</b> None
10001<p>
10002
10003<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_zddDivideF">Cudd_zddDivideF</a>
10004</code>
10005
10006<dt><pre>
10007DdNode  * <i></i>
10008<a name="cuddZddDivide"><b>cuddZddDivide</b></a>(
10009  DdManager * <b>dd</b>, <i></i>
10010  DdNode * <b>f</b>, <i></i>
10011  DdNode * <b>g</b> <i></i>
10012)
10013</pre>
10014<dd> Performs the recursive step of Cudd_zddDivide.
10015<p>
10016
10017<dd> <b>Side Effects</b> None
10018<p>
10019
10020<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_zddDivide">Cudd_zddDivide</a>
10021</code>
10022
10023<dt><pre>
10024void <i></i>
10025<a name="cuddZddFreeUniv"><b>cuddZddFreeUniv</b></a>(
10026  DdManager * <b>zdd</b> <i></i>
10027)
10028</pre>
10029<dd> Frees the ZDD universe.
10030<p>
10031
10032<dd> <b>Side Effects</b> None
10033<p>
10034
10035<dd> <b>See Also</b> <code><a href="cuddAllDet.html#cuddZddInitUniv">cuddZddInitUniv</a>
10036</code>
10037
10038<dt><pre>
10039int <i></i>
10040<a name="cuddZddGetCofactors2"><b>cuddZddGetCofactors2</b></a>(
10041  DdManager * <b>dd</b>, <i></i>
10042  DdNode * <b>f</b>, <i></i>
10043  int  <b>v</b>, <i></i>
10044  DdNode ** <b>f1</b>, <i></i>
10045  DdNode ** <b>f0</b> <i></i>
10046)
10047</pre>
10048<dd> Computes the two-way decomposition of f w.r.t. v.
10049<p>
10050
10051<dd> <b>Side Effects</b> The results are returned in f1 and f0.
10052<p>
10053
10054<dd> <b>See Also</b> <code><a href="cuddAllDet.html#cuddZddGetCofactors3">cuddZddGetCofactors3</a>
10055</code>
10056
10057<dt><pre>
10058int <i></i>
10059<a name="cuddZddGetCofactors3"><b>cuddZddGetCofactors3</b></a>(
10060  DdManager * <b>dd</b>, <i></i>
10061  DdNode * <b>f</b>, <i></i>
10062  int  <b>v</b>, <i></i>
10063  DdNode ** <b>f1</b>, <i></i>
10064  DdNode ** <b>f0</b>, <i></i>
10065  DdNode ** <b>fd</b> <i></i>
10066)
10067</pre>
10068<dd> Computes the three-way decomposition of function f (represented by a ZDD) wit respect to variable v.
10069<p>
10070
10071<dd> <b>Side Effects</b> The results are returned in f1, f0, and fd.
10072<p>
10073
10074<dd> <b>See Also</b> <code><a href="cuddAllDet.html#cuddZddGetCofactors2">cuddZddGetCofactors2</a>
10075</code>
10076
10077<dt><pre>
10078int <i></i>
10079<a name="cuddZddGetNegVarIndex"><b>cuddZddGetNegVarIndex</b></a>(
10080  DdManager * <b>dd</b>, <i></i>
10081  int  <b>index</b> <i></i>
10082)
10083</pre>
10084<dd> Returns the index of negative ZDD variable.
10085<p>
10086
10087<dt><pre>
10088int <i></i>
10089<a name="cuddZddGetNegVarLevel"><b>cuddZddGetNegVarLevel</b></a>(
10090  DdManager * <b>dd</b>, <i></i>
10091  int  <b>index</b> <i></i>
10092)
10093</pre>
10094<dd> Returns the level of negative ZDD variable.
10095<p>
10096
10097<dt><pre>
10098DdNode * <i></i>
10099<a name="cuddZddGetNodeIVO"><b>cuddZddGetNodeIVO</b></a>(
10100  DdManager * <b>dd</b>, <i></i>
10101  int  <b>index</b>, <i></i>
10102  DdNode * <b>g</b>, <i></i>
10103  DdNode * <b>h</b> <i></i>
10104)
10105</pre>
10106<dd> Wrapper for cuddUniqueInterZdd that is independent of variable ordering (IVO). This function does not require parameter index to precede the indices of the top nodes of g and h in the variable order. Returns a pointer to the result node under normal conditions; NULL if reordering occurred or memory was exhausted.
10107<p>
10108
10109<dd> <b>Side Effects</b> None
10110<p>
10111
10112<dd> <b>See Also</b> <code><a href="cuddAllDet.html#cuddZddGetNode">cuddZddGetNode</a>
10113<a href="cuddAllDet.html#cuddZddIsop">cuddZddIsop</a>
10114</code>
10115
10116<dt><pre>
10117DdNode * <i></i>
10118<a name="cuddZddGetNode"><b>cuddZddGetNode</b></a>(
10119  DdManager * <b>zdd</b>, <i></i>
10120  int  <b>id</b>, <i></i>
10121  DdNode * <b>T</b>, <i></i>
10122  DdNode * <b>E</b> <i></i>
10123)
10124</pre>
10125<dd> Wrapper for cuddUniqueInterZdd, which applies the ZDD reduction rule. Returns a pointer to the result node under normal conditions; NULL if reordering occurred or memory was exhausted.
10126<p>
10127
10128<dd> <b>Side Effects</b> None
10129<p>
10130
10131<dd> <b>See Also</b> <code><a href="cuddAllDet.html#cuddUniqueInterZdd">cuddUniqueInterZdd</a>
10132</code>
10133
10134<dt><pre>
10135int <i></i>
10136<a name="cuddZddGetPosVarIndex"><b>cuddZddGetPosVarIndex</b></a>(
10137  DdManager * <b>dd</b>, <i></i>
10138  int  <b>index</b> <i></i>
10139)
10140</pre>
10141<dd> Returns the index of positive ZDD variable.
10142<p>
10143
10144<dt><pre>
10145int <i></i>
10146<a name="cuddZddGetPosVarLevel"><b>cuddZddGetPosVarLevel</b></a>(
10147  DdManager * <b>dd</b>, <i></i>
10148  int  <b>index</b> <i></i>
10149)
10150</pre>
10151<dd> Returns the level of positive ZDD variable.
10152<p>
10153
10154<dt><pre>
10155int <i></i>
10156<a name="cuddZddInitUniv"><b>cuddZddInitUniv</b></a>(
10157  DdManager * <b>zdd</b> <i></i>
10158)
10159</pre>
10160<dd> Initializes the ZDD universe. Returns 1 if successful; 0 otherwise.
10161<p>
10162
10163<dd> <b>Side Effects</b> None
10164<p>
10165
10166<dd> <b>See Also</b> <code><a href="cuddAllDet.html#cuddZddFreeUniv">cuddZddFreeUniv</a>
10167</code>
10168
10169<dt><pre>
10170DdNode * <i></i>
10171<a name="cuddZddIntersect"><b>cuddZddIntersect</b></a>(
10172  DdManager * <b>zdd</b>, <i></i>
10173  DdNode * <b>P</b>, <i></i>
10174  DdNode * <b>Q</b> <i></i>
10175)
10176</pre>
10177<dd> Performs the recursive step of Cudd_zddIntersect.
10178<p>
10179
10180<dd> <b>Side Effects</b> None
10181<p>
10182
10183<dt><pre>
10184DdNode  * <i></i>
10185<a name="cuddZddIsop"><b>cuddZddIsop</b></a>(
10186  DdManager * <b>dd</b>, <i></i>
10187  DdNode * <b>L</b>, <i></i>
10188  DdNode * <b>U</b>, <i></i>
10189  DdNode ** <b>zdd_I</b> <i></i>
10190)
10191</pre>
10192<dd> Performs the recursive step of Cudd_zddIsop.
10193<p>
10194
10195<dd> <b>Side Effects</b> None
10196<p>
10197
10198<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_zddIsop">Cudd_zddIsop</a>
10199</code>
10200
10201<dt><pre>
10202DdNode * <i></i>
10203<a name="cuddZddIte"><b>cuddZddIte</b></a>(
10204  DdManager * <b>dd</b>, <i></i>
10205  DdNode * <b>f</b>, <i></i>
10206  DdNode * <b>g</b>, <i></i>
10207  DdNode * <b>h</b> <i></i>
10208)
10209</pre>
10210<dd> Performs the recursive step of Cudd_zddIte.
10211<p>
10212
10213<dd> <b>Side Effects</b> None
10214<p>
10215
10216<dt><pre>
10217int <i></i>
10218<a name="cuddZddLinearSifting"><b>cuddZddLinearSifting</b></a>(
10219  DdManager * <b>table</b>, <i></i>
10220  int  <b>lower</b>, <i></i>
10221  int  <b>upper</b> <i></i>
10222)
10223</pre>
10224<dd> Implementation of the linear sifting algorithm for ZDDs. Assumes that no dead nodes are present. <ol> <li> Order all the variables according to the number of entries in each unique table. <li> Sift the variable up and down and applies the XOR transformation, remembering each time the total size of the DD heap. <li> Select the best permutation. <li> Repeat 3 and 4 for all variables. </ol> Returns 1 if successful; 0 otherwise.
10225<p>
10226
10227<dd> <b>Side Effects</b> None
10228<p>
10229
10230<dt><pre>
10231int <i></i>
10232<a name="cuddZddNextHigh"><b>cuddZddNextHigh</b></a>(
10233  DdManager * <b>table</b>, <i></i>
10234  int  <b>x</b> <i></i>
10235)
10236</pre>
10237<dd> Finds the next subtable with a larger index. Returns the index.
10238<p>
10239
10240<dd> <b>Side Effects</b> None
10241<p>
10242
10243<dt><pre>
10244int <i></i>
10245<a name="cuddZddNextLow"><b>cuddZddNextLow</b></a>(
10246  DdManager * <b>table</b>, <i></i>
10247  int  <b>x</b> <i></i>
10248)
10249</pre>
10250<dd> Finds the next subtable with a smaller index. Returns the index.
10251<p>
10252
10253<dd> <b>Side Effects</b> None
10254<p>
10255
10256<dt><pre>
10257DdNode  * <i></i>
10258<a name="cuddZddProduct"><b>cuddZddProduct</b></a>(
10259  DdManager * <b>dd</b>, <i></i>
10260  DdNode * <b>f</b>, <i></i>
10261  DdNode * <b>g</b> <i></i>
10262)
10263</pre>
10264<dd> Performs the recursive step of Cudd_zddProduct.
10265<p>
10266
10267<dd> <b>Side Effects</b> None
10268<p>
10269
10270<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_zddProduct">Cudd_zddProduct</a>
10271</code>
10272
10273<dt><pre>
10274int <i></i>
10275<a name="cuddZddP"><b>cuddZddP</b></a>(
10276  DdManager * <b>zdd</b>, <i></i>
10277  DdNode * <b>f</b> <i></i>
10278)
10279</pre>
10280<dd> Prints a ZDD to the standard output. One line per node is printed. Returns 1 if successful; 0 otherwise.
10281<p>
10282
10283<dd> <b>Side Effects</b> None
10284<p>
10285
10286<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_zddPrintDebug">Cudd_zddPrintDebug</a>
10287</code>
10288
10289<dt><pre>
10290int <i></i>
10291<a name="cuddZddSifting"><b>cuddZddSifting</b></a>(
10292  DdManager * <b>table</b>, <i></i>
10293  int  <b>lower</b>, <i></i>
10294  int  <b>upper</b> <i></i>
10295)
10296</pre>
10297<dd> Implementation of Rudell's sifting algorithm. Assumes that no dead nodes are present. <ol> <li> Order all the variables according to the number of entries in each unique table. <li> Sift the variable up and down, remembering each time the total size of the DD heap. <li> Select the best permutation. <li> Repeat 3 and 4 for all variables. </ol> Returns 1 if successful; 0 otherwise.
10298<p>
10299
10300<dd> <b>Side Effects</b> None
10301<p>
10302
10303<dt><pre>
10304DdNode * <i></i>
10305<a name="cuddZddSubset0"><b>cuddZddSubset0</b></a>(
10306  DdManager * <b>dd</b>, <i></i>
10307  DdNode * <b>P</b>, <i></i>
10308  int  <b>var</b> <i></i>
10309)
10310</pre>
10311<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. cuddZddSubset0 performs the same function as Cudd_zddSubset0, but does not restart if reordering has taken place. Therefore it can be called from within a recursive procedure.
10312<p>
10313
10314<dd> <b>Side Effects</b> None
10315<p>
10316
10317<dd> <b>See Also</b> <code><a href="cuddAllDet.html#cuddZddSubset1">cuddZddSubset1</a>
10318<a href="cuddAllDet.html#Cudd_zddSubset0">Cudd_zddSubset0</a>
10319</code>
10320
10321<dt><pre>
10322DdNode * <i></i>
10323<a name="cuddZddSubset1"><b>cuddZddSubset1</b></a>(
10324  DdManager * <b>dd</b>, <i></i>
10325  DdNode * <b>P</b>, <i></i>
10326  int  <b>var</b> <i></i>
10327)
10328</pre>
10329<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. cuddZddSubset1 performs the same function as Cudd_zddSubset1, but does not restart if reordering has taken place. Therefore it can be called from within a recursive procedure.
10330<p>
10331
10332<dd> <b>Side Effects</b> None
10333<p>
10334
10335<dd> <b>See Also</b> <code><a href="cuddAllDet.html#cuddZddSubset0">cuddZddSubset0</a>
10336<a href="cuddAllDet.html#Cudd_zddSubset1">Cudd_zddSubset1</a>
10337</code>
10338
10339<dt><pre>
10340int <i></i>
10341<a name="cuddZddSwapInPlace"><b>cuddZddSwapInPlace</b></a>(
10342  DdManager * <b>table</b>, <i></i>
10343  int  <b>x</b>, <i></i>
10344  int  <b>y</b> <i></i>
10345)
10346</pre>
10347<dd> Swaps two adjacent variables. It assumes that no dead nodes are present on entry to this procedure. The procedure then guarantees that no dead nodes will be present when it terminates. cuddZddSwapInPlace assumes that x &lt; y. Returns the number of keys in the table if successful; 0 otherwise.
10348<p>
10349
10350<dd> <b>Side Effects</b> None
10351<p>
10352
10353<dt><pre>
10354int <i></i>
10355<a name="cuddZddSwapping"><b>cuddZddSwapping</b></a>(
10356  DdManager * <b>table</b>, <i></i>
10357  int  <b>lower</b>, <i></i>
10358  int  <b>upper</b>, <i></i>
10359  Cudd_ReorderingType  <b>heuristic</b> <i></i>
10360)
10361</pre>
10362<dd> Implementation of Plessier's algorithm that reorders variables by a sequence of (non-adjacent) swaps. <ol> <li> Select two variables (RANDOM or HEURISTIC). <li> Permute these variables. <li> If the nodes have decreased accept the permutation. <li> Otherwise reconstruct the original heap. <li> Loop. </ol> Returns 1 in case of success; 0 otherwise.
10363<p>
10364
10365<dd> <b>Side Effects</b> None
10366<p>
10367
10368<dt><pre>
10369int <i></i>
10370<a name="cuddZddSymmCheck"><b>cuddZddSymmCheck</b></a>(
10371  DdManager * <b>table</b>, <i></i>
10372  int  <b>x</b>, <i></i>
10373  int  <b>y</b> <i></i>
10374)
10375</pre>
10376<dd> Checks for symmetry of x and y. Ignores projection functions, unless they are isolated. Returns 1 in case of symmetry; 0 otherwise.
10377<p>
10378
10379<dd> <b>Side Effects</b> None
10380<p>
10381
10382<dt><pre>
10383int <i></i>
10384<a name="cuddZddSymmSiftingConv"><b>cuddZddSymmSiftingConv</b></a>(
10385  DdManager * <b>table</b>, <i></i>
10386  int  <b>lower</b>, <i></i>
10387  int  <b>upper</b> <i></i>
10388)
10389</pre>
10390<dd> Symmetric sifting to convergence algorithm for ZDDs. Assumes that no dead nodes are present. <ol> <li> Order all the variables according to the number of entries in each unique subtable. <li> Sift the variable up and down, remembering each time the total size of the ZDD heap and grouping variables that are symmetric. <li> Select the best permutation. <li> Repeat 3 and 4 for all variables. <li> Repeat 1-4 until no further improvement. </ol> Returns 1 plus the number of symmetric variables if successful; 0 otherwise.
10391<p>
10392
10393<dd> <b>Side Effects</b> None
10394<p>
10395
10396<dd> <b>See Also</b> <code><a href="cuddAllDet.html#cuddZddSymmSifting">cuddZddSymmSifting</a>
10397</code>
10398
10399<dt><pre>
10400int <i></i>
10401<a name="cuddZddSymmSifting"><b>cuddZddSymmSifting</b></a>(
10402  DdManager * <b>table</b>, <i></i>
10403  int  <b>lower</b>, <i></i>
10404  int  <b>upper</b> <i></i>
10405)
10406</pre>
10407<dd> Symmetric sifting algorithm. Assumes that no dead nodes are present. <ol> <li> Order all the variables according to the number of entries in each unique subtable. <li> Sift the variable up and down, remembering each time the total size of the ZDD heap and grouping variables that are symmetric. <li> Select the best permutation. <li> Repeat 3 and 4 for all variables. </ol> Returns 1 plus the number of symmetric variables if successful; 0 otherwise.
10408<p>
10409
10410<dd> <b>Side Effects</b> None
10411<p>
10412
10413<dd> <b>See Also</b> <code><a href="cuddAllDet.html#cuddZddSymmSiftingConv">cuddZddSymmSiftingConv</a>
10414</code>
10415
10416<dt><pre>
10417int <i></i>
10418<a name="cuddZddTreeSifting"><b>cuddZddTreeSifting</b></a>(
10419  DdManager * <b>table</b>, <i>DD table</i>
10420  Cudd_ReorderingType  <b>method</b> <i>reordering method for the groups of leaves</i>
10421)
10422</pre>
10423<dd> Tree sifting algorithm for ZDDs. Assumes that a tree representing a group hierarchy is passed as a parameter. It then reorders each group in postorder fashion by calling zddTreeSiftingAux. Assumes that no dead nodes are present. Returns 1 if successful; 0 otherwise.
10424<p>
10425
10426<dd> <b>Side Effects</b> None
10427<p>
10428
10429<dt><pre>
10430DdNode  * <i></i>
10431<a name="cuddZddUnateProduct"><b>cuddZddUnateProduct</b></a>(
10432  DdManager * <b>dd</b>, <i></i>
10433  DdNode * <b>f</b>, <i></i>
10434  DdNode * <b>g</b> <i></i>
10435)
10436</pre>
10437<dd> Performs the recursive step of Cudd_zddUnateProduct.
10438<p>
10439
10440<dd> <b>Side Effects</b> None
10441<p>
10442
10443<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_zddUnateProduct">Cudd_zddUnateProduct</a>
10444</code>
10445
10446<dt><pre>
10447DdNode * <i></i>
10448<a name="cuddZddUnion"><b>cuddZddUnion</b></a>(
10449  DdManager * <b>zdd</b>, <i></i>
10450  DdNode * <b>P</b>, <i></i>
10451  DdNode * <b>Q</b> <i></i>
10452)
10453</pre>
10454<dd> Performs the recursive step of Cudd_zddUnion.
10455<p>
10456
10457<dd> <b>Side Effects</b> None
10458<p>
10459
10460<dt><pre>
10461int <i></i>
10462<a name="cuddZddUniqueCompare"><b>cuddZddUniqueCompare</b></a>(
10463  int * <b>ptr_x</b>, <i></i>
10464  int * <b>ptr_y</b> <i></i>
10465)
10466</pre>
10467<dd> Comparison function used by qsort to order the variables according to the number of keys in the subtables. Returns the difference in number of keys between the two variables being compared.
10468<p>
10469
10470<dd> <b>Side Effects</b> None
10471<p>
10472
10473<dt><pre>
10474DdNode  * <i></i>
10475<a name="cuddZddWeakDivF"><b>cuddZddWeakDivF</b></a>(
10476  DdManager * <b>dd</b>, <i></i>
10477  DdNode * <b>f</b>, <i></i>
10478  DdNode * <b>g</b> <i></i>
10479)
10480</pre>
10481<dd> Performs the recursive step of Cudd_zddWeakDivF.
10482<p>
10483
10484<dd> <b>Side Effects</b> None
10485<p>
10486
10487<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_zddWeakDivF">Cudd_zddWeakDivF</a>
10488</code>
10489
10490<dt><pre>
10491DdNode  * <i></i>
10492<a name="cuddZddWeakDiv"><b>cuddZddWeakDiv</b></a>(
10493  DdManager * <b>dd</b>, <i></i>
10494  DdNode * <b>f</b>, <i></i>
10495  DdNode * <b>g</b> <i></i>
10496)
10497</pre>
10498<dd> Performs the recursive step of Cudd_zddWeakDiv.
10499<p>
10500
10501<dd> <b>Side Effects</b> None
10502<p>
10503
10504<dd> <b>See Also</b> <code><a href="cuddAllDet.html#Cudd_zddWeakDiv">Cudd_zddWeakDiv</a>
10505</code>
10506
10507<dt><pre>
10508 <i></i>
10509<a name="ddAbs"><b>ddAbs</b></a>(
10510   <b>x</b> <i></i>
10511)
10512</pre>
10513<dd> Computes the absolute value of a number.
10514<p>
10515
10516<dd> <b>Side Effects</b> none
10517<p>
10518
10519<dt><pre>
10520 <i></i>
10521<a name="ddCHash2"><b>ddCHash2</b></a>(
10522   <b>o</b>, <i></i>
10523   <b>f</b>, <i></i>
10524   <b>g</b>, <i></i>
10525   <b>s</b> <i></i>
10526)
10527</pre>
10528<dd> Hash function for the cache for functions with two operands.
10529<p>
10530
10531<dd> <b>Side Effects</b> none
10532<p>
10533
10534<dd> <b>See Also</b> <code><a href="ddAllDet.html#ddHash">ddHash</a>
10535<a href="ddAllDet.html#ddCHash">ddCHash</a>
10536</code>
10537
10538<dt><pre>
10539 <i></i>
10540<a name="ddCHash"><b>ddCHash</b></a>(
10541   <b>o</b>, <i></i>
10542   <b>f</b>, <i></i>
10543   <b>g</b>, <i></i>
10544   <b>h</b>, <i></i>
10545   <b>s</b> <i></i>
10546)
10547</pre>
10548<dd> Hash function for the cache.
10549<p>
10550
10551<dd> <b>Side Effects</b> none
10552<p>
10553
10554<dd> <b>See Also</b> <code><a href="ddAllDet.html#ddHash">ddHash</a>
10555<a href="ddAllDet.html#ddCHash2">ddCHash2</a>
10556</code>
10557
10558<dt><pre>
10559 <i></i>
10560<a name="ddEqualVal"><b>ddEqualVal</b></a>(
10561   <b>x</b>, <i></i>
10562   <b>y</b>, <i></i>
10563   <b>e</b> <i></i>
10564)
10565</pre>
10566<dd> Returns 1 if the absolute value of the difference of the two arguments x and y is less than e.
10567<p>
10568
10569<dd> <b>Side Effects</b> none
10570<p>
10571
10572<dt><pre>
10573 <i></i>
10574<a name="ddHash"><b>ddHash</b></a>(
10575   <b>f</b>, <i></i>
10576   <b>g</b>, <i></i>
10577   <b>s</b> <i></i>
10578)
10579</pre>
10580<dd> Hash function for the unique table.
10581<p>
10582
10583<dd> <b>Side Effects</b> none
10584<p>
10585
10586<dd> <b>See Also</b> <code><a href="ddAllDet.html#ddCHash">ddCHash</a>
10587<a href="ddAllDet.html#ddCHash2">ddCHash2</a>
10588</code>
10589
10590<dt><pre>
10591 <i></i>
10592<a name="ddLCHash2"><b>ddLCHash2</b></a>(
10593   <b>f</b>, <i></i>
10594   <b>g</b>, <i></i>
10595   <b>shift</b> <i></i>
10596)
10597</pre>
10598<dd> Computes hash function for keys of two operands.
10599<p>
10600
10601<dd> <b>Side Effects</b> None
10602<p>
10603
10604<dd> <b>See Also</b> <code><a href="ddAllDet.html#ddLCHash3">ddLCHash3</a>
10605<a href="ddAllDet.html#ddLCHash">ddLCHash</a>
10606</code>
10607
10608<dt><pre>
10609 <i></i>
10610<a name="ddLCHash3"><b>ddLCHash3</b></a>(
10611   <b>f</b>, <i></i>
10612   <b>g</b>, <i></i>
10613   <b>h</b>, <i></i>
10614   <b>shift</b> <i></i>
10615)
10616</pre>
10617<dd> Computes hash function for keys of three operands.
10618<p>
10619
10620<dd> <b>Side Effects</b> None
10621<p>
10622
10623<dd> <b>See Also</b> <code><a href="ddAllDet.html#ddLCHash2">ddLCHash2</a>
10624<a href="ddAllDet.html#ddLCHash">ddLCHash</a>
10625</code>
10626
10627<dt><pre>
10628 <i></i>
10629<a name="ddMax"><b>ddMax</b></a>(
10630   <b>x</b>, <i></i>
10631   <b>y</b> <i></i>
10632)
10633</pre>
10634<dd> Computes the maximum of two numbers.
10635<p>
10636
10637<dd> <b>Side Effects</b> none
10638<p>
10639
10640<dd> <b>See Also</b> <code><a href="ddAllDet.html#ddMin">ddMin</a>
10641</code>
10642
10643<dt><pre>
10644 <i></i>
10645<a name="ddMin"><b>ddMin</b></a>(
10646   <b>x</b>, <i></i>
10647   <b>y</b> <i></i>
10648)
10649</pre>
10650<dd> Computes the minimum of two numbers.
10651<p>
10652
10653<dd> <b>Side Effects</b> none
10654<p>
10655
10656<dd> <b>See Also</b> <code><a href="ddAllDet.html#ddMax">ddMax</a>
10657</code>
10658
10659<dt><pre>
10660 <i></i>
10661<a name="lqHash"><b>lqHash</b></a>(
10662   <b>key</b>, <i></i>
10663   <b>shift</b> <i></i>
10664)
10665</pre>
10666<dd> Hash function for the table of a level queue.
10667<p>
10668
10669<dd> <b>Side Effects</b> None
10670<p>
10671
10672<dd> <b>See Also</b> <code><a href="hashAllDet.html#hashInsert">hashInsert</a>
10673<a href="hashAllDet.html#hashLookup">hashLookup</a>
10674<a href="hashAllDet.html#hashDelete">hashDelete</a>
10675</code>
10676
10677<dt><pre>
10678 <i></i>
10679<a name="statLine"><b>statLine</b></a>(
10680   <b>dd</b> <i></i>
10681)
10682</pre>
10683<dd> Outputs a line of stats if DD_COUNT and DD_STATS are defined. Increments the number of recursive calls if DD_COUNT is defined.
10684<p>
10685
10686<dd> <b>Side Effects</b> None
10687<p>
10688
10689
10690</dl>
10691
10692<hr>
10693
10694Generated automatically by <code>extdoc</code> on 20050517
10695
10696</body></html>
Note: See TracBrowser for help on using the repository browser.