Biddy  1.7.3
An academic Binary Decision Diagrams package
biddy-example-8queens.c
1 /* $Revision: 300 $ */
2 /* $Date: 2017-09-08 15:51:12 +0200 (pet, 08 sep 2017) $ */
3 /* This file (biddy-example-8queens.c) is a C file */
4 /* Author: Robert Meolic (robert.meolic@um.si) */
5 /* This file has been released into the public domain by the author. */
6 
7 /* This example is compatible with Biddy v1.7 and CUDD v3.0.0 */
8 
9 /* COMPILE WITH: */
10 /* gcc -DREPORT -DNOPROFILE -DEVENTLOG_NONE -DUSE_BIDDY -DUSE_OBDDC -DUNIX -O2 -o biddy-example-8queens-obdd biddy-example-8queens.c -I. -L./bin -lbiddy -lgmp */
11 /* gcc -DREPORT -DNOPROFILE -DEVENTLOG_NONE -DUSE_BIDDY -DUSE_ZBDDC -DUNIX -O2 -o biddy-example-8queens-zbdd biddy-example-8queens.c -I. -L./bin -lbiddy -lgmp */
12 /* gcc -DREPORT -DNOPROFILE -DEVENTLOG_NONE -DUSE_BIDDY -DUSE_TZBDD -DUNIX -O2 -o biddy-example-8queens-tzbdd biddy-example-8queens.c -I. -L./bin -lbiddy -lgmp */
13 /* gcc -DREPORT -DEVENTLOG_NONE -DUSE_CUDD -DUSE_OBDDC -O2 -o cudd-example-8queens-obdd biddy-example-8queens.c -I ../cudd/include/ -L ../cudd/lib/ -lcudd -lm */
14 /* gcc -DREPORT -DEVENTLOG_NONE -DUSE_CUDD -DUSE_ZBDDC -O2 -o cudd-example-8queens-zbdd biddy-example-8queens.c -I ../cudd/include/ -L ../cudd/lib/ -lcudd -lm */
15 
16 /* for stats with more details, use BIDDYEXTENDEDSTATS_YES in biddyInt.h and use -lm for linking */
17 
18 /* default size, this can be overriden via argument */
19 #define SIZE 9
20 #define USE_GARBAGE_COLLECTION
21 
22 /* for BIDDY there are 3 variants possible: */
23 /* NOT_USE_SIFTING, USE_SIFTING, USE_SIFTING_R */
24 #define NOT_USE_SIFTING
25 
26 /* there are 5 variants possible */
27 /* NOT_POSTPONE, POSTPONE_FIFO, POSTPONE_LIFO, POSTPONE_REVERSE_FIFO, POSTPONE_REVERSE_LIFO */
28 #define NOT_POSTPONE
29 
30 /* event log (EVENTLOG_TIME, EVENTLOG_SIZE, or EVENTLOG_RESULT) */
31 #ifdef EVENTLOG_TIME
32 # define ZF_LOGI(x) {static unsigned int zfstat = 0;printf(x);printf("#%u,%.2f\n",++zfstat,clock()/(1.0*CLOCKS_PER_SEC));}
33 #endif
34 #ifdef EVENTLOG_SIZE
35 # ifdef USE_BIDDY
36 # define ZF_LOGI(x) {static unsigned int zfstat = 0;printf(x);printf("#%u,%u,%u\n",++zfstat,Biddy_NodeTableNum(),Biddy_NodeTableSize());}
37 # endif
38 # ifdef USE_CUDD
39 # define ZF_LOGI(x) {static unsigned int zfstat = 0;printf(x);printf("#%u,%u,%u\n",++zfstat,Cudd_ReadKeys(manager),Cudd_ReadSlots(manager));}
40 # endif
41 #endif
42 #ifdef EVENTLOG_RESULT
43 # ifdef USE_BIDDY
44 # define ZF_LOGI(x) {static unsigned int zfstat = 0;printf(x);printf("#%u,%u\n",++zfstat,Biddy_NodeNumber(r));}
45 # endif
46 # ifdef USE_CUDD
47 # define ZF_LOGI(x) {static unsigned int zfstat = 0;printf(x);printf("#%u,%u\n",++zfstat,Cudd_DagSize(r));}
48 # endif
49 #endif
50 #ifndef ZF_LOGI
51 # define ZF_LOGI(x)
52 #endif
53 
54 #ifdef USE_BIDDY
55 # include "biddy.h"
56 # define BDDNULL NULL
57 #endif
58 
59 #ifdef USE_CUDD
60 # include <stdio.h>
61 # include <stdlib.h>
62 # include <stdint.h>
63 # include <string.h>
64 # include <ctype.h>
65 # include <stdarg.h>
66 # include <math.h>
67 # include "cudd.h"
68 # define BDDNULL NULL
69 # ifndef TRUE
70 # define TRUE (0 == 0)
71 # endif
72 # ifndef FALSE
73 # define FALSE !TRUE
74 # endif
75 typedef char *Biddy_String;
76 typedef char Biddy_Boolean;
77 typedef DdNode *Biddy_Edge;
78 DdManager *manager;
79 #endif
80 
81 #include <time.h>
82 
83 #ifdef USE_BIDDY
84 #define REF(f) 0
85 #define DEREF(f) 0
86 #ifdef USE_GARBAGE_COLLECTION
87 #define MARK(f) Biddy_AddTmpFormula(f,1)
88 #define MARK_N(f,n) Biddy_AddTmpFormula(f,n)
89 #define SWEEP() Biddy_Clean()
90 #else
91 #define MARK(f) 0
92 #define MARK_N(f,n) 0
93 #define SWEEP() 0
94 #endif
95 #endif
96 
97 #ifdef USE_CUDD
98 #ifndef USE_ZBDDC
99 #ifndef USE_OBDDC
100 #define USE_OBDDC
101 #endif
102 #endif
103 #define BIDDYTYPEOBDD 1
104 #define BIDDYTYPEOBDDC 2
105 #define BIDDYTYPEZBDD 3
106 #define BIDDYTYPEZBDDC 4
107 #define BIDDYTYPETZBDD 5
108 #define BIDDYTYPETZBDDC 6
109 #define MARK(f) 0
110 #define MARK_N(f,n) 0
111 #define SWEEP() 0
112 #ifdef USE_OBDDC
113 #define REF(f) Cudd_Ref(f)
114 #define DEREF(f) Cudd_RecursiveDeref(manager,f)
115 #define Biddy_GetManagerType() BIDDYTYPEOBDDC
116 #define Biddy_GetConstantZero() Cudd_ReadLogicZero(manager)
117 #define Biddy_GetConstantOne() Cudd_ReadOne(manager)
118 #define Biddy_AddVariable() Cudd_bddNewVar(manager)
119 #define Biddy_Not(f) Cudd_Not(f)
120 #define Biddy_And(f,g) Cudd_bddAnd(manager,f,g)
121 #define Biddy_Or(f,g) Cudd_bddOr(manager,f,g)
122 #define Biddy_DependentVariableNumber(f) Cudd_SupportSize(manager,f)
123 #define Biddy_CountMinterm(f,n) Cudd_CountMinterm(manager,f,n)
124 #elif USE_ZBDDC
125 #define REF(f) Cudd_Ref(f)
126 #define DEREF(f) Cudd_RecursiveDerefZdd(manager,f)
127 #define Biddy_GetManagerType() BIDDYTYPEZBDDC
128 #define Biddy_GetConstantZero() Cudd_ReadZero(manager)
129 #define Biddy_GetConstantOne() Cudd_ReadZddOne(manager,0)
130 #define Biddy_AddVariable() Cudd_zddIthVar(manager,Cudd_ReadZddSize(manager))
131 #define Biddy_Not(f) Cudd_zddDiff(manager,Cudd_ReadZddOne(manager,0),f)
132 #define Biddy_And(f,g) Cudd_zddIntersect(manager,f,g)
133 #define Biddy_Or(f,g) Cudd_zddUnion(manager,f,g)
134 #define Biddy_DependentVariableNumber(f) Cudd_ReadZddSize(manager) /* this is not always valid but there is no better option */
135 #define Biddy_CountMinterm(f,n) Cudd_zddCountMinterm(manager,f,n)
136 #endif
137 #define Biddy_NodeNumber(f) Cudd_DagSize(f)
138 #define Biddy_DensityBDD(f,n) Cudd_Density(manager,f,n)
139 #define Biddy_NodeTableNum() Cudd_ReadKeys(manager)
140 #define Biddy_NodeTableSize() Cudd_ReadSlots(manager)
141 #define Biddy_ReadMemoryInUse() Cudd_ReadMemoryInUse(manager)
142 #define Biddy_PrintInfo(s) Cudd_PrintInfo(manager,s)
143 #endif
144 
145 void checkOutOfLimits(unsigned int size, clock_t elapsedtime) {
146 #ifdef USE_BIDDY
147  if ((size == 10) && (Biddy_NodeTableSize() > 4194304)) {
148  fprintf(stderr,"10, -1, -1, -1\n");
149  exit(0);
150  }
151  if ((size == 9) && (Biddy_ReadMemoryInUse() > 120000000)) {
152  fprintf(stderr,"9, -1, -1, -1\n");
153  exit(0);
154  }
155  if ((size == 10) && (Biddy_ReadMemoryInUse() > 350000000)) {
156  fprintf(stderr,"10, -1, -1, -1\n");
157  exit(0);
158  }
159 #endif
160 }
161 
162 int main(int argc, char** argv) {
163  unsigned int i,j,k,n,size,seq;
164  Biddy_Edge **board,**board_not;
165  Biddy_Edge tmp;
166  Biddy_Edge t,r;
167  Biddy_Edge *fifo1,*LP1;
168  Biddy_Edge *fifo2,*LP2;
169 #if defined(POSTPONE_FIFO) || defined(POSTPONE_REVERSE_FIFO)
170  unsigned int seq1;
171 #endif
172 
173  clock_t elapsedtime;
174 
175  if (argc > 1) {
176 #pragma warning(suppress: 6031)
177  sscanf(argv[1],"%u",&size);
178  } else {
179  size = SIZE;
180  }
181 
182  if ((size < 2) || (size > 15)) {
183  printf("WRONG SIZE!\n");
184  exit(0);
185  }
186 
187  setbuf(stdout, NULL);
188 
189 #ifdef PROFILE
190  printf("!!!");
191 #endif
192 
193  elapsedtime = clock();
194 
195  LP1 = fifo1 = (Biddy_Edge *) malloc((4 * size * size + size) * sizeof(Biddy_Edge));
196  LP2 = fifo2 = (Biddy_Edge *) malloc((4 * size * size + size) * sizeof(Biddy_Edge));
197  LP1--;
198 
199 #ifdef USE_BIDDY
200  seq = 0;
201 #endif
202 
203  board = (Biddy_Edge **) malloc((size+1)*sizeof(Biddy_Edge *));
204  board_not = (Biddy_Edge **) malloc((size+1)*sizeof(Biddy_Edge *));
205  for (i=0; i<=size; i++) {
206  board[i] = (Biddy_Edge *) malloc((size+1)*sizeof(Biddy_Edge));
207  board_not[i] = (Biddy_Edge *) malloc((size+1)*sizeof(Biddy_Edge));
208  }
209 
210 #ifdef USE_BIDDY
211  /* There is only one unique table in Biddy */
212  /* There are three caches in Biddy */
213  /* New nodes are added in blocks */
214  /* The max number of variables is hardcoded in biddyInt. h */
215  /* biddyVariableTable.size = BIDDYVARMAX = 2048 */
216  /* The following constants are hardcoded in biddyMain.c */
217  /* biddyNodeTable.size = BIG_TABLE = 1048575 */
218  /* biddyIteCache.size = MEDIUM_TABLE = 262143 */
219  /* biddyEACache.size = SMALL_TABLE = 65535 */
220  /* biddyRCCache.size = SMALL_TABLE = 65535 */
221  /* biddyBlockSize = 524288 */
222  /* DEFAULT INIT CALL: Biddy_InitAnonymous(BIDDYTYPEOBDDC) */
223 #ifdef USE_OBDDC
224  Biddy_InitAnonymous(BIDDYTYPEOBDDC);
225 #elif USE_ZBDDC
226  Biddy_InitAnonymous(BIDDYTYPEZBDDC);
227 #elif USE_TZBDD
228  Biddy_InitAnonymous(BIDDYTYPETZBDD);
229 #else
230  Biddy_InitAnonymous(BIDDYTYPEOBDDC);
231 #endif
232  if ((argc == 1) || (argc == 2)) {
233  Biddy_SetManagerParameters(-1,-1,-1,-1,-1,-1,-1,-1,-1,-1);
234  }
235  else if (argc == 8) {
236  int gcr,gcrF,gcrX;
237  int rr,rrF,rrX;
238 #pragma warning(suppress: 6031)
239  sscanf(argv[2],"%d",&gcr);
240 #pragma warning(suppress: 6031)
241  sscanf(argv[3],"%d",&gcrF);
242 #pragma warning(suppress: 6031)
243  sscanf(argv[4],"%d",&gcrX);
244 #pragma warning(suppress: 6031)
245  sscanf(argv[5],"%d",&rr);
246 #pragma warning(suppress: 6031)
247  sscanf(argv[6],"%d",&rrF);
248 #pragma warning(suppress: 6031)
249  sscanf(argv[7],"%d",&rrX);
250 #pragma warning(suppress: 4244)
251  Biddy_SetManagerParameters(gcr/100.0,gcrF/100.0,gcrX/100.0,rr/100.0,rrF/100.0,rrX/100.0,-1,-1,-1,-1);
252  printf("%d, %d, %d, %d, %d, %d, ",gcr,gcrF,gcrX,rr,rrF,rrX);
253  }
254  else if (argc == 12) {
255  int gcr,gcrF,gcrX;
256  int rr,rrF,rrX;
257  int st;
258  int fst;
259  int cst;
260  int fcst;
261 #pragma warning(suppress: 6031)
262  sscanf(argv[2],"%d",&gcr);
263 #pragma warning(suppress: 6031)
264  sscanf(argv[3],"%d",&gcrF);
265 #pragma warning(suppress: 6031)
266  sscanf(argv[4],"%d",&gcrX);
267 #pragma warning(suppress: 6031)
268  sscanf(argv[5],"%d",&rr);
269 #pragma warning(suppress: 6031)
270  sscanf(argv[6],"%d",&rrF);
271 #pragma warning(suppress: 6031)
272  sscanf(argv[7],"%d",&rrX);
273 #pragma warning(suppress: 6031)
274  sscanf(argv[8],"%d",&st);
275 #pragma warning(suppress: 6031)
276  sscanf(argv[9],"%d",&fst);
277 #pragma warning(suppress: 6031)
278  sscanf(argv[10],"%d",&cst);
279 #pragma warning(suppress: 6031)
280  sscanf(argv[11],"%d",&fcst);
281 #pragma warning(suppress: 4244)
282  Biddy_SetManagerParameters(gcr/100.0,gcrF/100.0,gcrX/100.0,rr/100.0,rrF/100.0,rrX/100.0,st/100.0,fst/100.0,cst/100.0,fcst/100.0);
283  printf("%d, %d, %d, %d, %d, %d, ",gcr,gcrF,gcrX,rr,rrF,rrX);
284  }
285  else {
286  printf("Wrong number of parameters!\n");
287  printf("USAGE (short): biddy-example-8queens SIZE GCR GCRF GCRX RR RRF RRX\n");
288  printf("USAGE (long): biddy-example-8queens SIZE GCR GCRF GCRX RR RRF RRX ST FST CST FCST\n");
289  printf("All parameters should be integer numbers >= 0");
290  exit(0);
291  }
292 #endif
293 
294 #ifdef USE_CUDD
295  /* In CUDD each variable has its own subtable in the unique table */
296  /* There is only one cache in CUDD */
297  /* Subtables grow over the time, you can set limit for fast unique table growth */
298  /* Cudd_SetLooseUpTo(manager,1048576) */
299  /* Cache can grow over the time, you can set the max size */
300  /* Cudd_SetMaxCacheHard(manager,262144) */
301  /* These two constants are hardcoded in v3.0.0 */
302  /* CUDD_UNIQUE_SLOTS = 256 (default initial size of each subtable) */
303  /* CUDD_CACHE_SLOTS = 262144 (default initial size of cache table) */
304  /* DEFAULT INIT CALL: Cudd_Init(0,0,CUDD_UNIQUE_SLOTS,CUDD_CACHE_SLOTS,0) */
305  manager = Cudd_Init(0,0,CUDD_UNIQUE_SLOTS,CUDD_CACHE_SLOTS,0);
306  Cudd_SetMaxCacheHard(manager,262144);
307 #ifndef USE_GARBAGE_COLLECTION
308  Cudd_DisableGarbageCollection(manager);
309 #endif
310 #endif
311 
312  for (i=1; i<=size; i++) {
313 #pragma warning(suppress: 6011)
314  board[0][i] = board[i][0] = NULL;
315  board_not[0][i] = board_not[i][0] = NULL;
316  }
317 
318  /* create BDD variables */
319  if ((Biddy_GetManagerType() == BIDDYTYPEOBDD) || (Biddy_GetManagerType() == BIDDYTYPEOBDDC) ||
320  (Biddy_GetManagerType() == BIDDYTYPETZBDD) || (Biddy_GetManagerType() == BIDDYTYPETZBDDC))
321  {
322  for (i=1; i<=size; i++) {
323  for (j=1; j<=size; j++) {
324  board[i][j] = Biddy_AddVariable();
325  REF(board[i][j]);
326  board_not[i][j] = Biddy_Not(board[i][j]);
327  REF(board_not[i][j]);
328  }
329  }
330  }
331 
332  /* for Biddy, ZBDD variables are added in the reverse order to get consistent results */
333 #ifdef USE_BIDDY
334  if ((Biddy_GetManagerType() == BIDDYTYPEZBDD) || (Biddy_GetManagerType() == BIDDYTYPEZBDDC))
335  {
336  for (i=1; i<=size; i++) {
337  for (j=1; j<=size; j++) {
338  board[size-i+1][size-j+1] = Biddy_AddVariable();
339  board_not[size-i+1][size-j+1] = Biddy_Not(board[size-i+1][size-j+1]);
340  }
341  }
342  }
343 #endif
344 #ifdef USE_CUDD
345  if ((Biddy_GetManagerType() == BIDDYTYPEZBDD) || (Biddy_GetManagerType() == BIDDYTYPEZBDDC))
346  {
347  for (i=1; i<=size; i++) {
348  for (j=1; j<=size; j++) {
349  board[i][j] = Biddy_AddVariable();
350  REF(board[i][j]);
351  board_not[i][j] = Biddy_Not(board[i][j]);
352  REF(board_not[i][j]);
353  }
354  }
355  }
356 #endif
357 
358  /* for ZBDDs, by adding new variables all the existing variables are changed */
359  /* after adding the last variable we have to refresh edges in board[i][j] and board_not[i][j] */
360  /* NOTE: for Biddy, ZBDD variables are added in the reverse order */
361  /* NOTE: for Biddy, user variables start with index 1 */
362  /* NOTE: for CUDD, user variables start with index 0 */
363  if ((Biddy_GetManagerType() == BIDDYTYPEZBDD) || (Biddy_GetManagerType() == BIDDYTYPEZBDDC))
364  {
365 #ifdef USE_BIDDY
366  /* user variables in Biddy start with index 1 */
367  for (i=1; i<=size; i++) {
368  for (j=1; j<=size; j++) {
369  board[i][j] = Biddy_GetVariableEdge(size*size-((i-1)*size+(j-1)));
370  board_not[i][j] = Biddy_Not(board[i][j]);
371  }
372  }
373 #endif
374 #ifdef USE_CUDD
375  /* user variables in CUDD start with index 0 */
376  for (i=1; i<=size; i++) {
377  for (j=1; j<=size; j++) {
378  DEREF(board[i][j]);
379  board[i][j] = Cudd_zddIthVar(manager,(i-1)*size+(j-1));
380  REF(board[i][j]);
381  DEREF(board_not[i][j]);
382  board_not[i][j] = Biddy_Not(board[i][j]);
383  REF(board_not[i][j]);
384  }
385  }
386 #endif
387  }
388 
389  /* for TZBDDs, by adding new variables the negations of all the existing variables are changed */
390  /* after adding the last variable we have to refresh edges in board_not[i][j] */
391  /* NOTE: TZBDDs are supported only in Biddy */
392  if ((Biddy_GetManagerType() == BIDDYTYPETZBDD) || (Biddy_GetManagerType() == BIDDYTYPETZBDDC))
393  {
394  for (i=1; i<=size; i++) {
395  for (j=1; j<=size; j++) {
396  board_not[i][j] = Biddy_Not(board[i][j]);
397  }
398  }
399  }
400 
401 /* TO DO: replace Biddy_AddPersistentFormula with the correct MARK_N */
402 #ifdef USE_BIDDY
403 #ifdef NOT_POSTPONE
404  if ((Biddy_GetManagerType() == BIDDYTYPEZBDD) || (Biddy_GetManagerType() == BIDDYTYPEZBDDC) ||
405  (Biddy_GetManagerType() == BIDDYTYPETZBDD) || (Biddy_GetManagerType() == BIDDYTYPETZBDDC))
406  {
407  for (i=1; i<=size; i++) {
408  for (j=1; j<=size; j++) {
409  Biddy_AddPersistentFormula(NULL,board_not[i][j]);
410  }
411  }
412  }
413 #endif
414 #endif
415 
416  r = Biddy_GetConstantOne();
417  REF(r);
418 
419  ZF_LOGI("INIT");
420 
421  /* ROWS */
422 #ifdef REPORT
423  printf("\nSTARTING ROWS\n");
424 #endif
425  for (i=1; i<=size; i++) {
426 #ifdef REPORT
427  printf("(%d/%d)",i,size);
428 #endif
429  for (j=1; j<=size; j++) {
430  t = Biddy_GetConstantOne();
431  REF(t);
432  for (k=1; k<=size; k++) {
433  if (k != j) {
434  ZF_LOGI("R_AND");
435  tmp = Biddy_And(t,board_not[i][k]);
436  REF(tmp);
437  DEREF(t);
438  t = tmp;
439  }
440  }
441  ZF_LOGI("R_OR");
442  tmp = Biddy_Or(t,board_not[i][j]);
443 #ifdef NOT_POSTPONE
444  MARK(r);
445  MARK(tmp);
446  SWEEP();
447 #endif
448  REF(tmp);
449  DEREF(t);
450  t = tmp;
451 
452 #ifdef NOT_POSTPONE
453  ZF_LOGI("R_AND");
454  tmp = Biddy_And(r,t);
455  MARK(tmp);
456  SWEEP();
457  REF(tmp);
458  DEREF(t);
459  DEREF(r);
460  r = tmp;
461 #else
462  *(++LP1) = t;
463 #endif
464 
465  ZF_LOGI("R_MEM");
466 
467 #ifdef POSTPONE_FIFO
468  seq++;
469  MARK_N(t,(seq-1)/2);
470 #endif
471 #ifdef POSTPONE_REVERSE_FIFO
472  seq++;
473  MARK_N(t,(4 * size * size + size - seq)/2);
474 #endif
475 #ifdef POSTPONE_LIFO
476  seq++;
477  if (seq == 1) {
478  MARK_N(t,seq-1);
479  } else {
480  MARK_N(t,seq-2);
481  }
482 #endif
483 #ifdef POSTPONE_REVERSE_LIFO
484  seq++;
485  MARK_N(t,(4 * size * size + size) - seq - 1);
486 #endif
487 
488  }
489  }
490 
491 #ifdef PROFILE
492  checkOutOfLimits(size,elapsedtime);
493 #endif
494 
495  /* SIFTING AFTER EACH MAJOR PART - IMPLEMENTED FOR BIDDY, ONLY */
496  /* IT IS NOT VERY EFFECTIVE FOR THIS PROBLEM */
497 #ifdef USE_BIDDY
498 #ifdef NOT_POSTPONE
499 #ifdef USE_SIFTING
500  ZF_LOGI("R_SIFT");
501  Biddy_Sifting(NULL,FALSE);
502 #endif
503 #ifdef USE_SIFTING_R
504  ZF_LOGI("R_SIFT_R");
505  Biddy_Sifting(r,FALSE);
506 #endif
507 #endif
508 #endif
509 
510  /* COLUMNS */
511 #ifdef REPORT
512  printf("\nSTARTING COLUMNS\n");
513 #endif
514  for (i=1; i<=size; i++) {
515 #ifdef REPORT
516  printf("(%d/%d)",i,size);
517 #endif
518  for (j=1; j<=size; j++) {
519  t = Biddy_GetConstantOne();
520  REF(t);
521  for (k=1; k<=size; k++) {
522  if (k != i) {
523  ZF_LOGI("C_AND");
524  tmp = Biddy_And(t,board_not[k][j]);
525  REF(tmp);
526  DEREF(t);
527  t = tmp;
528  }
529  }
530  ZF_LOGI("C_OR");
531  tmp = Biddy_Or(t,board_not[i][j]);
532 #ifdef NOT_POSTPONE
533  MARK(r);
534  MARK(tmp);
535  SWEEP();
536 #endif
537  REF(tmp);
538  DEREF(t);
539  t = tmp;
540 
541 #ifdef NOT_POSTPONE
542  ZF_LOGI("C_AND");
543  tmp = Biddy_And(r,t);
544  MARK(tmp);
545  SWEEP();
546  REF(tmp);
547  DEREF(t);
548  DEREF(r);
549  r = tmp;
550 #else
551  *(++LP1) = t;
552 #endif
553 
554  ZF_LOGI("C_MEM");
555 
556 #ifdef POSTPONE_FIFO
557  seq++;
558  MARK_N(t,(seq-1)/2);
559 #endif
560 #ifdef POSTPONE_REVERSE_FIFO
561  seq++;
562  MARK_N(t,(4 * size * size + size - seq)/2);
563 #endif
564 #ifdef POSTPONE_LIFO
565  seq++;
566  MARK_N(t,seq-2);
567 #endif
568 #ifdef POSTPONE_REVERSE_LIFO
569  seq++;
570  MARK_N(t,(4 * size * size + size) - seq - 1);
571 #endif
572 
573  }
574  }
575 
576 #ifdef PROFILE
577  checkOutOfLimits(size,elapsedtime);
578 #endif
579 
580  /* SIFTING AFTER EACH MAJOR PART - IMPLEMENTED FOR BIDDY, ONLY */
581  /* IT IS NOT VERY EFFECTIVE FOR THIS PROBLEM */
582 #ifdef USE_BIDDY
583 #ifdef NOT_POSTPONE
584 #ifdef USE_SIFTING
585  ZF_LOGI("C_SIFT");
586  Biddy_Sifting(NULL,FALSE);
587 #endif
588 #ifdef USE_SIFTING_R
589  ZF_LOGI("C_SIFT_R");
590  Biddy_Sifting(r,FALSE);
591 #endif
592 #endif
593 #endif
594 
595  /* RISING DIAGONALS */
596 #ifdef REPORT
597  printf("\nSTARTING RISING DIAGONALS\n");
598 #endif
599  for (i=1; i<=size; i++) {
600 #ifdef REPORT
601  printf("(%d/%d)",i,size);
602 #endif
603  for (j=1; j<=size; j++) {
604  t = Biddy_GetConstantOne();
605  REF(t);
606  for (k=1; k<=size; k++) {
607  if ((j+k-i >= 1) && (j+k-i <= size) && (k != i)) {
608  ZF_LOGI("RD_AND");
609  tmp = Biddy_And(t,board_not[k][j+k-i]);
610  REF(tmp);
611  DEREF(t);
612  t = tmp;
613  }
614  }
615  ZF_LOGI("RD_OR");
616  tmp = Biddy_Or(t,board_not[i][j]);
617 #ifdef NOT_POSTPONE
618  MARK(r);
619  MARK(tmp);
620  SWEEP();
621 #endif
622  REF(tmp);
623  DEREF(t);
624  t = tmp;
625 
626 #ifdef NOT_POSTPONE
627  ZF_LOGI("RD_AND");
628  tmp = Biddy_And(r,t);
629  MARK(tmp);
630  SWEEP();
631  REF(tmp);
632  DEREF(t);
633  DEREF(r);
634  r = tmp;
635 #else
636  *(++LP1) = t;
637 #endif
638 
639  ZF_LOGI("RD_MEM");
640 
641 #ifdef POSTPONE_FIFO
642  seq++;
643  MARK_N(t,(seq-1)/2);
644 #endif
645 #ifdef POSTPONE_REVERSE_FIFO
646  seq++;
647  MARK_N(t,(4 * size * size + size - seq)/2);
648 #endif
649 #ifdef POSTPONE_LIFO
650  seq++;
651  MARK_N(t,seq-2);
652 #endif
653 #ifdef POSTPONE_REVERSE_LIFO
654  seq++;
655  MARK_N(t,(4 * size * size + size) - seq - 1);
656 #endif
657 
658  }
659  }
660 
661 #ifdef PROFILE
662  checkOutOfLimits(size,elapsedtime);
663 #endif
664 
665  /* SIFTING AFTER EACH MAJOR PART - IMPLEMENTED FOR BIDDY, ONLY */
666  /* IT IS NOT VERY EFFECTIVE FOR THIS PROBLEM */
667 #ifdef USE_BIDDY
668 #ifdef NOT_POSTPONE
669 #ifdef USE_SIFTING
670  ZF_LOGI("RD_SIFT");
671  Biddy_Sifting(NULL,FALSE);
672 #endif
673 #ifdef USE_SIFTING_R
674  ZF_LOGI("RD_SIFT_R");
675  Biddy_Sifting(r,FALSE);
676 #endif
677 #endif
678 #endif
679 
680  /* FALLING DIAGONALS */
681 #ifdef REPORT
682  printf("\nSTARTING FALLING DIAGONALS\n");
683 #endif
684  for (i=1; i<=size; i++) {
685 #ifdef REPORT
686  printf("(%d/%d)",i,size);
687 #endif
688  for (j=1; j<=size; j++) {
689  t = Biddy_GetConstantOne();
690  REF(t);
691  for (k=1; k<=size; k++) {
692  if ((j+i-k >= 1) && (j+i-k <= size) && (k != i)) {
693  ZF_LOGI("FD_AND");
694  tmp = Biddy_And(t,board_not[k][j+i-k]);
695  REF(tmp);
696  DEREF(t);
697  t = tmp;
698  }
699  }
700  ZF_LOGI("FD_OR");
701 #pragma warning(suppress: 6011)
702  tmp = Biddy_Or(t,board_not[i][j]);
703 #ifdef NOT_POSTPONE
704  MARK(r);
705  MARK(tmp);
706  SWEEP();
707 #endif
708  REF(tmp);
709  DEREF(t);
710  t = tmp;
711 
712 #ifdef NOT_POSTPONE
713  ZF_LOGI("FD_AND");
714  tmp = Biddy_And(r,t);
715  MARK(tmp);
716  SWEEP();
717  REF(tmp);
718  DEREF(t);
719  DEREF(r);
720  r = tmp;
721 #else
722  *(++LP1) = t;
723 #endif
724 
725  ZF_LOGI("FD_MEM");
726 
727 #ifdef POSTPONE_FIFO
728  seq++;
729  MARK_N(t,(seq-1)/2);
730 #endif
731 #ifdef POSTPONE_REVERSE_FIFO
732  seq++;
733  MARK_N(t,(4 * size * size + size - seq)/2);
734 #endif
735 #ifdef POSTPONE_LIFO
736  seq++;
737  MARK_N(t,seq-2);
738 #endif
739 #ifdef POSTPONE_REVERSE_LIFO
740  seq++;
741  MARK_N(t,(4 * size * size + size) - seq - 1);
742 #endif
743 
744  }
745  }
746 
747 #ifdef PROFILE
748  checkOutOfLimits(size,elapsedtime);
749 #endif
750 
751  /* SIFTING AFTER EACH MAJOR PART - IMPLEMENTED FOR BIDDY, ONLY */
752  /* IT IS NOT VERY EFFECTIVE FOR THIS PROBLEM */
753 #ifdef USE_BIDDY
754 #ifdef NOT_POSTPONE
755 #ifdef USE_SIFTING
756  ZF_LOGI("FD_SIFT");
757  Biddy_Sifting(NULL,FALSE);
758 #endif
759 #ifdef USE_SIFTING_R
760  ZF_LOGI("FD_SIFT_R");
761  Biddy_Sifting(r,FALSE);
762 #endif
763 #endif
764 #endif
765 
766  /* THERE MUST BE A QUEEN IN EACH ROW */
767 #ifdef REPORT
768  printf("\nSTARTING FINAL CALCULATONS\n");
769 #endif
770  for (i=1; i<=size; i++) {
771 #ifdef REPORT
772  printf("(%d/%d)",i,size);
773 #endif
774  t = Biddy_GetConstantZero();
775  REF(t);
776  for (j=1; j<=size; j++) {
777  ZF_LOGI("F_OR");
778  tmp = Biddy_Or(t,board[i][j]);
779  REF(tmp);
780  DEREF(t);
781  t = tmp;
782  }
783 
784 #ifdef NOT_POSTPONE
785  ZF_LOGI("F_AND");
786  tmp = Biddy_And(r,t);
787  MARK(tmp);
788  SWEEP();
789  REF(tmp);
790  DEREF(t);
791  DEREF(r);
792  r = tmp;
793 #else
794  *(++LP1) = t;
795 #endif
796 
797  ZF_LOGI("F_MEM");
798 
799 #ifdef POSTPONE_FIFO
800  seq++;
801  MARK_N(t,(seq-1)/2);
802 #endif
803 #ifdef POSTPONE_REVERSE_FIFO
804  seq++;
805  MARK_N(t,(4 * size * size + size - seq)/2);
806 #endif
807 #ifdef POSTPONE_LIFO
808  seq++;
809  MARK_N(t,seq-2);
810 #endif
811 #ifdef POSTPONE_REVERSE_LIFO
812  seq++;
813  if (seq == (4 * size *size + size)) {
814  MARK_N(t,4 * size * size + size - seq);
815  } else {
816  MARK_N(t,4 * size * size + size - seq - 1);
817  }
818 #endif
819 
820 #ifdef PROFILE
821  checkOutOfLimits(size,elapsedtime);
822 #endif
823 
824  }
825 
826 #ifdef PROFILE
827  checkOutOfLimits(size,elapsedtime);
828 #endif
829 
830  /* SIFTING AFTER EACH MAJOR PART - IMPLEMENTED FOR BIDDY, ONLY */
831  /* IT IS NOT VERY EFFECTIVE FOR THIS PROBLEM */
832 #ifdef USE_BIDDY
833 #ifdef NOT_POSTPONE
834 #ifdef USE_SIFTING
835  ZF_LOGI("FD_SIFT");
836  Biddy_Sifting(NULL,FALSE);
837 #endif
838 #ifdef USE_SIFTING_R
839  ZF_LOGI("FD_SIFT_R");
840  Biddy_Sifting(r,FALSE);
841 #endif
842 #endif
843 #endif
844 
845  ZF_LOGI("P_MEM");
846 
847 /* POSTPONED ELEMENTS WILL BE CALCULATED IN REVERSED ORDER */
848 #if defined(POSTPONE_FIFO) || defined(POSTPONE_LIFO)
849  LP1++;
850  LP2 = fifo2;
851  LP2--;
852  while(LP1 != fifo1) {
853  *(++LP2) = *(--LP1);
854  }
855  fifo1 = fifo2;
856  fifo2 = LP1;
857  LP1 = LP2;
858 #endif
859 
860 #ifdef NOT_POSTPONE
861 #ifdef REPORT
862  printf("\nAnd OPERATIONS ARE NOT POSTPONED\n");
863 #endif
864 #endif
865 
866 /* POSTPONE And OPERATIONS USING FIFO */
867 #if defined(POSTPONE_FIFO) || defined(POSTPONE_REVERSE_FIFO)
868 #ifdef REPORT
869  printf("\nPOSTPONED And OPERATIONS USING FIFO\n");
870 #endif
871  DEREF(r);
872  i = 0;
873  do {
874  LP1++;
875  LP2 = fifo2;
876  LP2--;
877  seq1 = (seq+1)/2;
878  seq = 0;
879  while(LP1 != fifo1) {
880  ZF_LOGI("P_MEM");
881  seq++;
882  r = *(--LP1);
883  if (LP1 == fifo1) {
884  *(++LP2) = r;
885  MARK_N(r,seq1+(seq-1)/2);
886  SWEEP();
887  seq1--;
888  } else {
889  t = *(--LP1);
890  ZF_LOGI("P_AND");
891  tmp = Biddy_And(r,t);
892  *(++LP2) = tmp;
893  MARK_N(tmp,seq1+(seq-1)/2);
894  SWEEP();
895  seq1--;
896  REF(tmp);
897  DEREF(manager,r);
898  DEREF(manager,t);
899  }
900  }
901  fifo1 = fifo2;
902  fifo2 = LP1;
903  LP1 = LP2;
904 
905  /* TO BE CONSISTENT YOU HAVE TO REVERSE ORDERING OF ELEMENTS */
906  LP1++;
907  LP2 = fifo2;
908  LP2--;
909  while(LP1 != fifo1) {
910  *(++LP2) = *(--LP1);
911  }
912  fifo1 = fifo2;
913  fifo2 = LP1;
914  LP1 = LP2;
915 
916  } while (LP1 != fifo1);
917  r = *(LP1);
918 #endif
919 
920 /* POSTPONE And OPERATIONS USING LIFO */
921 #if defined(POSTPONE_LIFO) || defined(POSTPONE_REVERSE_LIFO)
922 #ifdef REPORT
923  printf("\nPOSTPONED And OPERATIONS USING LIFO\n");
924 #endif
925  DEREF(r);
926  i = 0;
927  while(LP1 != fifo1) {
928  r = *(LP1--);
929  t = *(LP1--);
930  ZF_LOGI("P_AND");
931  tmp = Biddy_And(r,t);
932  *(++LP1) = tmp;
933  MARK(tmp);
934  SWEEP();
935  REF(tmp);
936  DEREF(r);
937  DEREF(t);
938  }
939  r = *(LP1);
940 #endif
941 
942  free(fifo1);
943  free(fifo2);
944 
945  /* SIFTING TO MINIMIZE THE RESULT - IMPLEMENTED FOR BIDDY, ONLY */
946 #ifdef USE_BIDDY
947 #ifdef NOT_POSTPONE
948 #ifdef USE_SIFTING
949  ZF_LOGI("F_SIFT");
950  Biddy_Sifting(NULL,FALSE);
951 #endif
952 #ifdef USE_SIFTING_R
953  ZF_LOGI("F_SIFT_R");
954  Biddy_Sifting(r,FALSE);
955 #endif
956 #endif
957 #endif
958 
959  ZF_LOGI("EXIT");
960 
961 #ifdef PROFILE
962  checkOutOfLimits(size,elapsedtime);
963 #endif
964 
965  elapsedtime = clock()-elapsedtime;
966 
967  /* RESULT */
968 #ifdef REPORT
969  printf("\n");
971  printf("Resulting function r has %.0f minterms.\n",Biddy_CountMinterm(r,n));
972  printf("Resulting function r depends on %u variables.\n",n);
973  printf("BDD for resulting function r has %u nodes.\n",Biddy_NodeNumber(r));
974  printf("BDD for the resulting function has density = %.2f.\n",Biddy_DensityBDD(r,0));
975 #ifdef USE_BIDDY
976  printf("Resulting function has density = %e.\n",Biddy_DensityFunction(r,0));
977  printf("BDD without complemented edges for resulting function r has %u nodes (including both constants).\n",Biddy_NodeNumberPlain(r));
978 #endif
979 #endif
980 
981  /* CONVERT TO OBDD AND REPORT THE SIZE OF THE EQUIVALENT OBDD - Biddy ONLY! */
982  /*
983  {
984  Biddy_Manager MNGOBDD;
985  Biddy_Edge obdd;
986  Biddy_InitMNG(&MNGOBDD,BIDDYTYPEOBDDC);
987  obdd = Biddy_Copy(MNGOBDD,r);
988  n = Biddy_Managed_DependentVariableNumber(MNGOBDD,obdd);
989  printf("Function represented by the equivalent OBDD depends on %u variables.\n",n);
990  printf("Function represented by the equivalent OBDD has %.0f minterms.\n",Biddy_Managed_CountMinterm(MNGOBDD,obdd,n));
991  printf("Function represented by the equivalent OBDD has density = %e.\n",Biddy_Managed_DensityFunction(MNGOBDD,obdd,0));
992  printf("Equivalent OBDD has %u nodes.\n",Biddy_Managed_NodeNumber(MNGOBDD,obdd));
993  printf("Equivalent OBDD without complemented edges for resulting function r has %u nodes (including both constants).\n",Biddy_Managed_NodeNumberPlain(MNGOBDD,obdd));
994  printf("Equivalent OBDD has density = %.2f.\n",Biddy_Managed_DensityBDD(MNGOBDD,obdd,0));
995  }
996  */
997 
998  /* CONVERT TO ZBDD AND REPORT THE SIZE OF THE EQUIVALENT TZBDD - Biddy ONLY! */
999  /*
1000  {
1001  Biddy_Manager MNGZBDD;
1002  Biddy_Edge zbdd;
1003  Biddy_InitMNG(&MNGZBDD,BIDDYTYPEZBDDC);
1004  zbdd = Biddy_Copy(MNGZBDD,r);
1005  printf("ZBDD for function r has %u nodes.\n",Biddy_Managed_NodeNumber(MNGZBDD,zbdd));
1006  }
1007  */
1008 
1009  /* CONVERT TO TZBDD AND REPORT THE SIZE OF THE EQUIVALENT TZBDD - Biddy ONLY! */
1010  /*
1011  {
1012  Biddy_Manager MNGTZBDD;
1013  Biddy_Edge tzbdd;
1014  Biddy_InitMNG(&MNGTZBDD,BIDDYTYPETZBDD);
1015  tzbdd = Biddy_Copy(MNGTZBDD,r);
1016  printf("TZBDD for function r has %u nodes.\n",Biddy_Managed_NodeNumber(MNGTZBDD,tzbdd));
1017  }
1018  */
1019 
1020  /* DUMP RESULT USING GRAPHVIZ/DOT */
1021  /*
1022 #ifdef USE_BIDDY
1023  Biddy_WriteDot("8queens-biddy.dot",r,"r",-1,FALSE);
1024 #elif USE_CUDD
1025  {
1026  FILE * fp;
1027  fp = fopen("8queens-cudd.dot","w");
1028  Cudd_DumpDot(manager,1,&r,NULL,NULL,fp);
1029  fclose(fp);
1030  }
1031 #endif
1032  */
1033 
1034  /* We have problems with passing stdout in the case you compile this file */
1035  /* with MINGW and use biddy.dll generated with Visual Studio. */
1036  /* In such cases, please, use Biddy_PrintInfo(NULL) */
1037 #ifdef REPORT
1038  printf("\n");
1039  Biddy_PrintInfo(stdout);
1040 #endif
1041 
1042  /* SIFTING ON THE RESULT - THIS IS NOT VERY EFFECTIVE FOR THIS PROBLEM */
1043  /*
1044 #ifdef USE_BIDDY
1045  Biddy_Sifting(NULL,FALSE);
1046 #endif
1047 #ifdef USE_CUDD
1048  Cudd_ReduceHeap(manager,CUDD_REORDER_SIFT,0);
1049 #endif
1050 #ifdef REPORT
1051  n = Biddy_DependentVariableNumber(r);
1052  printf("(AFTER SIFTING) Resulting function r depends on %u variables.\n",n);
1053  printf("(AFTER SIFTING) Resulting function r has %.0f minterms.\n",Biddy_CountMinterm(r,n));
1054  printf("(AFTER SIFTING) BDD for resulting function r has %u nodes.\n",Biddy_NodeNumber(r));
1055 #endif
1056  */
1057 
1058 #ifndef REPORT
1059  /*
1060  if (Biddy_GetManagerType() == BIDDYTYPEOBDDC) {
1061  fprintf(stderr,"(OBDDC) ");
1062  }
1063  else if (Biddy_GetManagerType() == BIDDYTYPEZBDDC) {
1064  fprintf(stderr,"(ZBDDC) ");
1065  }
1066  else if (Biddy_GetManagerType() == BIDDYTYPETZBDD) {
1067  fprintf(stderr,"(TZBDD) ");
1068  }
1069  else {
1070  fprintf(stderr,"(unknown BDD type)");
1071  exit(0);
1072  }
1073  n = Biddy_DependentVariableNumber(r);
1074  fprintf(stderr,"Resulting function r has %.0f minterms.\n",Biddy_CountMinterm(r,n));
1075  */
1076 #endif
1077 
1078  /* REPORT ELAPSED TIME */
1079  /*
1080  fprintf(stderr,"clock() TIME = %.2f\n",elapsedtime/(1.0*CLOCKS_PER_SEC));
1081  */
1082 
1083 #ifdef REPORT
1084  printf("\nCALCULATION FINISHED\n");
1085 #endif
1086 
1087  /* PROFILING */
1088  /**/
1089 #ifdef USE_BIDDY
1090  fprintf(stderr,"#%u, ",size);
1091 #ifdef MINGW
1092  fprintf(stderr,"%I64u, ",Biddy_ReadMemoryInUse());
1093 #else
1094  fprintf(stderr,"%llu, ",Biddy_ReadMemoryInUse());
1095 #endif
1096 /*
1097  if (Biddy_NodeTableFoaNumber()) {
1098  fprintf(stderr,"%llu, ",Biddy_NodeTableFoaNumber());
1099  }
1100  if (Biddy_NodeTableFindNumber()) {
1101  fprintf(stderr,"%llu, ",Biddy_NodeTableFindNumber());
1102  }
1103  if (Biddy_NodeTableCompareNumber()) {
1104  fprintf(stderr,"%llu, ",Biddy_NodeTableCompareNumber());
1105  }
1106  if (Biddy_NodeTableAddNumber()) {
1107  fprintf(stderr,"%llu, ",Biddy_NodeTableAddNumber());
1108  }
1109 */
1110  fprintf(stderr,"%u, ",Biddy_NodeTableGCNumber());
1112  fprintf(stderr,"%llu, ",Biddy_NodeTableGCObsoleteNumber());
1113  }
1115  fprintf(stderr,"%llu, ",Biddy_NodeTableANDORRecursiveNumber());
1116  }
1117  fprintf(stderr,"%.2f, ",Biddy_NodeTableGCTime()/(1.0*CLOCKS_PER_SEC));
1118  fprintf(stderr,"%.2f",elapsedtime/(1.0*CLOCKS_PER_SEC));
1119  fprintf(stderr,",\n");
1120 #endif
1121 #ifdef USE_CUDD
1122  fprintf(stderr,"%u, ",size);
1123  fprintf(stderr,"%zu, ",Cudd_ReadMemoryInUse(manager));
1124  fprintf(stderr,"0, ");
1125  fprintf(stderr,"%.2f\n",elapsedtime/(1.0*CLOCKS_PER_SEC));
1126 #endif
1127  /**/
1128 
1129  /* PROFILING */
1130  /*
1131  printf("\n");
1132  Biddy_PrintInfo(stdout);
1133  */
1134 
1135  /* EXIT */
1136  for (i=1; i<=size; i++) {
1137  for (j=1; j<=size; j++) {
1138  DEREF(board[i][j]);
1139  DEREF(board_not[i][j]);
1140  }
1141  }
1142  DEREF(r);
1143  free(board);
1144  free(board_not);
1145 #ifdef USE_BIDDY
1146  Biddy_Exit();
1147 #endif
1148 #ifdef USE_CUDD
1149 #ifdef REPORT
1150  printf("CUDD: nodes with non-zero reference counts: %d\n",Cudd_CheckZeroRef(manager));
1151 #endif
1152  Cudd_Quit(manager);
1153 #endif
1154 
1155 }
#define Biddy_NodeTableGCNumber()
Definition: biddy.h:856
#define Biddy_CountMinterm(f, nvars)
Definition: biddy.h:982
void * Biddy_Edge
Definition: biddy.h:250
#define Biddy_GetManagerType()
Definition: biddy.h:309
#define Biddy_And(f, g)
Definition: biddy.h:517
#define Biddy_Sifting(f, c)
Definition: biddy.h:735
#define Biddy_DependentVariableNumber(f)
Definition: biddy.h:961
#define Biddy_NodeNumberPlain(f)
Definition: biddy.h:956
#define Biddy_GetConstantOne()
Definition: biddy.h:381
#define Biddy_PrintInfo(f)
Definition: biddy.h:1004
#define Biddy_Or(f, g)
Definition: biddy.h:525
#define Biddy_NodeTableGCTime()
Definition: biddy.h:861
#define Biddy_DensityFunction(f, nvars)
Definition: biddy.h:989
#define Biddy_NodeNumber(f)
Definition: biddy.h:781
#define Biddy_Not(f)
Definition: biddy.h:506
#define Biddy_GetConstantZero()
Definition: biddy.h:374
#define Biddy_NodeTableGCObsoleteNumber()
Definition: biddy.h:866
#define Biddy_Exit()
Definition: biddy.h:301
File biddy.h contains declaration of all external data structures.
char Biddy_Boolean
Definition: biddy.h:220
#define Biddy_NodeTableSize()
Definition: biddy.h:801
#define Biddy_GetVariableEdge(v)
Definition: biddy.h:408
#define Biddy_ReadMemoryInUse()
Definition: biddy.h:999
#define Biddy_SetManagerParameters(gcr, gcrF, gcrX, rr, rrF, rrX, st, fst, cst, fcst)
Definition: biddy.h:319
#define Biddy_DensityBDD(f, nvars)
Definition: biddy.h:994
#define Biddy_NodeTableANDORRecursiveNumber()
Definition: biddy.h:901
char * Biddy_String
Definition: biddy.h:223