buddy: rename libbdd to libbddx
* buddy/src/bdd.h, buddy/src/bvec.h, buddy/src/fdd.h: Rename as... * buddy/src/bddx.h, buddy/src/bvecx.h, buddy/src/fddx.h: ... these. * buddy/src/Makefile.am: Build libbddx.la instead of libbdd.la. * buddy/examples/Makefile.def: Use it. * Makefile.am, buddy/src/bddtest.cxx, buddy/src/bvec.c, buddy/src/cppext.cxx, buddy/src/fdd.c, buddy/src/imatrix.h, buddy/src/kernel.h, buddy/examples/adder/adder.cxx, buddy/examples/bddcalc/parser_.h, buddy/examples/bddtest/bddtest.cxx, buddy/examples/cmilner/cmilner.c, buddy/examples/fdd/fdd.cxx, buddy/examples/milner/milner.cxx, buddy/examples/money/money.cxx, buddy/examples/queen/queen.cxx, buddy/examples/solitare/solitare.cxx, m4/buddy.m4, src/ltlvisit/apcollect.hh, src/ltlvisit/simplify.hh, src/misc/bddlt.hh, src/misc/bddop.hh, src/misc/minato.hh, src/priv/acccompl.hh, src/priv/accconv.hh, src/priv/accmap.hh, src/priv/bddalloc.cc, src/tgba/bdddict.hh, src/tgba/bddprint.hh, src/tgba/tgbamask.hh, src/tgba/tgbasafracomplement.cc, src/tgbaalgos/emptiness.hh, src/tgbaalgos/gtec/sccstack.hh, src/tgbaalgos/neverclaim.cc, src/tgbaalgos/powerset.cc, src/tgbaalgos/sccfilter.hh, src/tgbaalgos/sccinfo.hh, src/tgbaalgos/weight.hh, wrap/python/buddy.i: Adjust. * NEWS, README: Document it.
This commit is contained in:
Alexandre Duret-Lutz
parent
f35be908c8
commit
ad8d24222a
45 changed files with 253 additions and 291 deletions
|
|
@ -1,2 +1,2 @@
|
|||
AM_CPPFLAGS = -I$(top_srcdir)/src -I$(srcdir)
|
||||
LDADD = $(top_builddir)/src/libbdd.la
|
||||
LDADD = $(top_builddir)/src/libbddx.la
|
||||
|
|
|
|||
|
|
@ -8,7 +8,7 @@
|
|||
#include <string.h>
|
||||
#include <time.h>
|
||||
#include <iostream>
|
||||
#include "bdd.h"
|
||||
#include "bddx.h"
|
||||
|
||||
using namespace std;
|
||||
|
||||
|
|
|
|||
|
|
@ -9,7 +9,7 @@
|
|||
#define _PARSER_H
|
||||
|
||||
#include <stdio.h>
|
||||
#include "bdd.h"
|
||||
#include "bddx.h"
|
||||
|
||||
#define MAXIDLEN 32 /* Max. number of allowed characters in an identifier */
|
||||
|
||||
|
|
|
|||
|
|
@ -1,6 +1,6 @@
|
|||
#include <iomanip>
|
||||
#include <stdlib.h>
|
||||
#include <bdd.h>
|
||||
#include <bddx.h>
|
||||
|
||||
static const int varnum = 5;
|
||||
|
||||
|
|
@ -47,9 +47,9 @@ void test1_check(bdd x)
|
|||
{
|
||||
using namespace std ;
|
||||
double anum = bdd_satcount(x);
|
||||
|
||||
|
||||
cout << "Checking bdd with " << setw(4) << anum << " assignments: ";
|
||||
|
||||
|
||||
allsatBDD = x;
|
||||
allsatSumBDD = bddfalse;
|
||||
|
||||
|
|
@ -107,7 +107,7 @@ void test1()
|
|||
int v = rand() % varnum;
|
||||
int s = rand() % 2;
|
||||
int o = rand() % 2;
|
||||
|
||||
|
||||
if (o == 0)
|
||||
{
|
||||
if (s == 0)
|
||||
|
|
@ -136,10 +136,10 @@ int main()
|
|||
{
|
||||
bdd_init(1000,1000);
|
||||
bdd_setvarnum(varnum);
|
||||
|
||||
|
||||
test1();
|
||||
|
||||
|
||||
bdd_done();
|
||||
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,7 +1,7 @@
|
|||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <math.h>
|
||||
#include "bdd.h"
|
||||
#include "bddx.h"
|
||||
|
||||
int N; /* Number of cyclers */
|
||||
int *normvar; /* Current state variables */
|
||||
|
|
@ -289,4 +289,3 @@ int main(int argc, char** argv)
|
|||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -6,7 +6,7 @@
|
|||
* 0 -> 1 -> 2 -> 3 -> 4 -> 5 -> -> 7 -> 0
|
||||
*/
|
||||
|
||||
#include "fdd.h"
|
||||
#include "fddx.h"
|
||||
|
||||
/* Use the transition relation "transRel" to iterate through the statespace
|
||||
*/
|
||||
|
|
@ -63,7 +63,7 @@ int main() {
|
|||
{
|
||||
/* Set the current state to be state 'i' */
|
||||
bdd current = fdd_ithvar(0,i);
|
||||
|
||||
|
||||
/* Set the next state to be state 'i+1' */
|
||||
bdd next = fdd_ithvar(1, (i+1) % 8);
|
||||
|
||||
|
|
|
|||
|
|
@ -1,7 +1,7 @@
|
|||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <math.h>
|
||||
#include "bdd.h"
|
||||
#include "bddx.h"
|
||||
#include <iostream>
|
||||
using namespace std;
|
||||
|
||||
|
|
@ -17,11 +17,11 @@ bdd A(bdd* x, bdd* y, int z)
|
|||
{
|
||||
bdd res = bddtrue;
|
||||
int i;
|
||||
|
||||
|
||||
for(i=0 ; i<N ; i++)
|
||||
if(i != z)
|
||||
res &= bdd_apply(x[i],y[i],bddop_biimp);
|
||||
|
||||
|
||||
return res;
|
||||
}
|
||||
|
||||
|
|
@ -35,19 +35,19 @@ bdd transitions(bdd* t, bdd* tp, bdd* h, bdd* hp, bdd* c, bdd* cp)
|
|||
bdd P; // Cycler i's handling of the token
|
||||
bdd E; // Cycler i's handling of it's task
|
||||
bdd T = bddfalse; // The monolithic transition relation
|
||||
|
||||
|
||||
for(i=0 ; i<N ; i++)
|
||||
{
|
||||
P = ((c[i]>cp[i]) & (tp[i]>t[i]) & hp[i] & A(c,cp,i)
|
||||
& A(t,tp,i) & A(h,hp,i))
|
||||
| ((h[i]>hp[i]) & cp[(i+1)%N] & A(c,cp,(i+1)%N) & A(h,hp,i)
|
||||
& A(t,tp,N));
|
||||
|
||||
|
||||
E = t[i] & !tp[i] & A(t,tp,i) & A(h,hp,N) & A(c,cp,N);
|
||||
|
||||
|
||||
T |= P | E;
|
||||
}
|
||||
|
||||
|
||||
return T;
|
||||
}
|
||||
|
||||
|
|
@ -58,10 +58,10 @@ bdd initial_state(bdd* t, bdd* h, bdd* c)
|
|||
{
|
||||
int i;
|
||||
bdd I = c[0] & !h[0] & !t[0];
|
||||
|
||||
|
||||
for(i=1; i<N; i++)
|
||||
I &= !c[i] & !h[i] & !t[i];
|
||||
|
||||
|
||||
return I;
|
||||
}
|
||||
|
||||
|
|
@ -90,7 +90,7 @@ bdd reachable_states(bdd I, bdd T)
|
|||
R |= tmp;
|
||||
}
|
||||
while(prevR != R);
|
||||
|
||||
|
||||
return R;
|
||||
}
|
||||
|
||||
|
|
@ -105,38 +105,38 @@ int main(int argc, char** argv)
|
|||
cerr << " N number of cyclers\n";
|
||||
exit(1);
|
||||
}
|
||||
|
||||
|
||||
N = atoi(argv[1]);
|
||||
if (N <= 0)
|
||||
{
|
||||
cerr << "The number of cyclers must be more than zero\n";
|
||||
exit(2);
|
||||
}
|
||||
|
||||
|
||||
bdd_init(500000, 50000);
|
||||
bdd_setvarnum(N*6);
|
||||
|
||||
|
||||
bdd* c = new bdd[N];
|
||||
bdd* cp = new bdd[N];
|
||||
bdd* t = new bdd[N];
|
||||
bdd* tp = new bdd[N];
|
||||
bdd* h = new bdd[N];
|
||||
bdd* hp = new bdd[N];
|
||||
|
||||
|
||||
int *nvar = new int[N*3];
|
||||
int *pvar = new int[N*3];
|
||||
|
||||
|
||||
for (n=0 ; n<N*3 ; n++)
|
||||
{
|
||||
nvar[n] = n*2;
|
||||
pvar[n] = n*2+1;
|
||||
}
|
||||
|
||||
|
||||
normvar = bdd_makeset(nvar, N*3);
|
||||
primvar = bdd_makeset(pvar, N*3);
|
||||
renamepair = bdd_newpair();
|
||||
bdd_setpairs(renamepair, pvar, nvar, N*3);
|
||||
|
||||
|
||||
for (n=0 ; n<N ; n++)
|
||||
{
|
||||
c[n] = bdd_ithvar(n*6);
|
||||
|
|
@ -161,7 +161,7 @@ int main(int argc, char** argv)
|
|||
bdd I = initial_state(t,h,c);
|
||||
bdd T = transitions(t,tp,h,hp,c,cp);
|
||||
bdd R = reachable_states(I,T);
|
||||
|
||||
|
||||
bddStat s;
|
||||
bdd_stats(&s);
|
||||
|
||||
|
|
@ -176,4 +176,3 @@ int main(int argc, char** argv)
|
|||
bdd_done();
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -1,4 +1,4 @@
|
|||
#include "bvec.h"
|
||||
#include "bvecx.h"
|
||||
#include <iostream>
|
||||
using namespace std;
|
||||
|
||||
|
|
@ -16,15 +16,15 @@ using namespace std;
|
|||
|
||||
int main(void)
|
||||
{
|
||||
using namespace std ;
|
||||
using namespace std ;
|
||||
// Allocate 11 domains with room for up to 3*10
|
||||
static int dom[11] = {30,30,30,30,30,30,30,30,30,30,30};
|
||||
|
||||
|
||||
bdd_init(10000,10000);
|
||||
fdd_extdomain(dom,11);
|
||||
|
||||
// Assign binary vectors (expressions) to the digits
|
||||
|
||||
|
||||
bvec s = bvec_varfdd(0); // The 's' digit
|
||||
bvec e = bvec_varfdd(1); // The 'e' digit
|
||||
bvec n = bvec_varfdd(2); // ...
|
||||
|
|
@ -50,7 +50,7 @@ int main(void)
|
|||
|
||||
// The use of "m1*10" instead of "m1*c10" avoids a bitnum mismatch since
|
||||
// "m1*10" results in 5 bits but "m1*c10" results in 10 bits!
|
||||
|
||||
|
||||
// And so on ...
|
||||
bdd t2 = (n + r + m1 == e + m2*10) & n<c10 & r<c10 & m2<c2;
|
||||
bdd t3 = (e + o + m2 == n + m3*10) & o<c10 & m3<c2;
|
||||
|
|
@ -71,6 +71,6 @@ int main(void)
|
|||
|
||||
// Print result
|
||||
cout << fddset << t << endl;
|
||||
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -23,11 +23,11 @@
|
|||
. . . X
|
||||
X . . .
|
||||
. . X .
|
||||
|
||||
|
||||
**************************************************************************/
|
||||
#include <stdlib.h>
|
||||
#include <iostream>
|
||||
#include "bdd.h"
|
||||
#include "bddx.h"
|
||||
using namespace std;
|
||||
|
||||
int N; /* Size of the chess board */
|
||||
|
|
@ -41,7 +41,7 @@ void build(int i, int j)
|
|||
{
|
||||
bdd a=bddtrue, b=bddtrue, c=bddtrue, d=bddtrue;
|
||||
int k,l;
|
||||
|
||||
|
||||
/* No one in the same column */
|
||||
for (l=0 ; l<N ; l++)
|
||||
if (l != j)
|
||||
|
|
@ -78,7 +78,7 @@ int main(int ac, char **av)
|
|||
{
|
||||
using namespace std ;
|
||||
int n,i,j;
|
||||
|
||||
|
||||
if (ac != 2)
|
||||
{
|
||||
fprintf(stderr, "USAGE: queen N\n");
|
||||
|
|
@ -97,7 +97,7 @@ int main(int ac, char **av)
|
|||
bdd_setvarnum(N*N);
|
||||
|
||||
queen = bddtrue;
|
||||
|
||||
|
||||
/* Build variable array */
|
||||
X = new bdd*[N];
|
||||
for (n=0 ; n<N ; n++)
|
||||
|
|
@ -115,7 +115,7 @@ int main(int ac, char **av)
|
|||
e |= X[i][j];
|
||||
queen &= e;
|
||||
}
|
||||
|
||||
|
||||
/* Build requirements for each variable(field) */
|
||||
for (i=0 ; i<N ; i++)
|
||||
for (j=0 ; j<N ; j++)
|
||||
|
|
@ -131,6 +131,6 @@ int main(int ac, char **av)
|
|||
cout << bddset << solution << endl;
|
||||
|
||||
bdd_done();
|
||||
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -2,7 +2,7 @@
|
|||
#include <unistd.h>
|
||||
#include <stdlib.h>
|
||||
#include <iostream>
|
||||
#include "bdd.h"
|
||||
#include "bddx.h"
|
||||
using std::cout;
|
||||
using std::endl;
|
||||
using std::flush;
|
||||
|
|
@ -23,7 +23,7 @@ bddPair *pair; // Renaming pair
|
|||
|
||||
|
||||
// All the possible moves. Note that the numbering starts from '1'
|
||||
int moves[][3] =
|
||||
int moves[][3] =
|
||||
{ {1,4,9}, {1,2,3},
|
||||
{2,5,10},
|
||||
{3,2,1}, {3,6,11},
|
||||
|
|
@ -68,7 +68,7 @@ int moves[][3] =
|
|||
void make_board(void)
|
||||
{
|
||||
bdd_setvarnum(SIZE*2);
|
||||
|
||||
|
||||
for (int n=0 ; n<SIZE ; n++)
|
||||
{
|
||||
boardC[n] = bdd_ithvar(n*2);
|
||||
|
|
@ -81,7 +81,7 @@ void make_board(void)
|
|||
void make_initial_state(void)
|
||||
{
|
||||
I = bddtrue;
|
||||
|
||||
|
||||
for (int n=0 ; n<SIZE ; n++)
|
||||
if (n == CENTER)
|
||||
I &= !boardC[n];
|
||||
|
|
@ -95,7 +95,7 @@ void make_initial_state(void)
|
|||
bdd all_other_idle(int src, int tmp, int dst)
|
||||
{
|
||||
bdd idle = bddtrue;
|
||||
|
||||
|
||||
for (int n=0 ; n<SIZE ; n++)
|
||||
{
|
||||
if (n != src && n != tmp && n != dst)
|
||||
|
|
@ -113,7 +113,7 @@ bdd make_move(int src, int tmp, int dst)
|
|||
!boardN[src] & !boardN[tmp] & boardN[dst];
|
||||
|
||||
move &= all_other_idle(src, tmp, dst);
|
||||
|
||||
|
||||
return move;
|
||||
}
|
||||
|
||||
|
|
@ -122,7 +122,7 @@ void make_transition_relation(void)
|
|||
{
|
||||
using namespace std ;
|
||||
T = bddfalse;
|
||||
|
||||
|
||||
for (int n=0 ; moves[n][0]!=moves[n][1] ; n++)
|
||||
T |= make_move(moves[n][0]-1, moves[n][1]-1, moves[n][2]-1);
|
||||
|
||||
|
|
@ -137,7 +137,7 @@ void make_itedata(void)
|
|||
pair = bdd_newpair();
|
||||
for (int n=0 ; n<SIZE ; n++)
|
||||
bdd_setpair(pair, n*2+1, n*2);
|
||||
|
||||
|
||||
currentvar = bddtrue;
|
||||
for (int n=0 ; n<SIZE ; n++)
|
||||
currentvar &= boardC[n];
|
||||
|
|
@ -152,7 +152,7 @@ void iterate(void)
|
|||
int cou = 1;
|
||||
|
||||
make_itedata();
|
||||
|
||||
|
||||
do
|
||||
{
|
||||
tmp = reachable;
|
||||
|
|
@ -177,7 +177,7 @@ void iterate_front(void)
|
|||
int cou = 1;
|
||||
|
||||
make_itedata();
|
||||
|
||||
|
||||
do
|
||||
{
|
||||
tmp = reachable;
|
||||
|
|
@ -201,7 +201,7 @@ void setup(void)
|
|||
bdd_init(100000,1000);
|
||||
bdd_setcacheratio(64);
|
||||
bdd_setmaxincrease(500000);
|
||||
|
||||
|
||||
dummyStateNum = pow(2.0, SIZE);
|
||||
|
||||
make_board();
|
||||
|
|
@ -217,4 +217,3 @@ int main(void)
|
|||
|
||||
system("ps aux | grep \"./solitare\" | grep -v \"grep\"");
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -1,14 +1,13 @@
|
|||
|
||||
include_HEADERS = bdd.h fdd.h bvec.h
|
||||
include_HEADERS = bddx.h fddx.h bvecx.h
|
||||
|
||||
BUDDY_FLAGS = -I$(top_builddir) -DVERSION=23 -DBUDDY_DLL_EXPORTS -DBUDDY_DLL
|
||||
|
||||
lib_LTLIBRARIES = libbdd.la
|
||||
lib_LTLIBRARIES = libbddx.la
|
||||
# See the `Updating version info' node of the Libtool manual before
|
||||
# changing this.
|
||||
libbdd_la_LDFLAGS = -no-undefined -version-info 0:0:0
|
||||
libbdd_la_CPPFLAGS = $(BUDDY_FLAGS)
|
||||
libbdd_la_SOURCES = \
|
||||
libbddx_la_LDFLAGS = -no-undefined -version-info 0:0:0
|
||||
libbddx_la_CPPFLAGS = $(BUDDY_FLAGS)
|
||||
libbddx_la_SOURCES = \
|
||||
bddio.c \
|
||||
bddop.c \
|
||||
bddtree.h \
|
||||
|
|
@ -30,4 +29,4 @@ libbdd_la_SOURCES = \
|
|||
check_PROGRAMS = bddtest
|
||||
bddtest_SOURCES = bddtest.cxx
|
||||
bddtest_CPPFLAGS = -I$(top_builddir)
|
||||
bddtest_LDADD = ./libbdd.la
|
||||
bddtest_LDADD = ./libbddx.la
|
||||
|
|
|
|||
|
|
@ -29,8 +29,8 @@
|
|||
|
||||
#include <string>
|
||||
#include <cstdlib>
|
||||
#include "bdd.h"
|
||||
#include "bvec.h"
|
||||
#include "bddx.h"
|
||||
#include "bvecx.h"
|
||||
|
||||
using namespace std;
|
||||
|
||||
|
|
|
|||
|
|
@ -35,8 +35,8 @@
|
|||
DATE: (C) feb 1997
|
||||
*************************************************************************/
|
||||
|
||||
#ifndef _BDD_H
|
||||
#define _BDD_H
|
||||
#ifndef _BDDX_H
|
||||
#define _BDDX_H
|
||||
|
||||
#if __GNUC__ >= 3
|
||||
#define __purefn __attribute__((__pure__))
|
||||
|
|
@ -1046,6 +1046,6 @@ BUDDY_API bddstrmhandler bdd_strm_hook(bddstrmhandler);
|
|||
|
||||
#endif /* CPLUSPLUS */
|
||||
|
||||
#endif /* _BDD_H */
|
||||
#endif /* _BDDX_H */
|
||||
|
||||
/* EOF */
|
||||
132
buddy/src/bvec.c
132
buddy/src/bvec.c
|
|
@ -1,5 +1,5 @@
|
|||
/*========================================================================
|
||||
Copyright (C) 1996-2002 by Jorn Lind-Nielsen
|
||||
Copyright (C) 1996-2002, 2014 by Jorn Lind-Nielsen
|
||||
All rights reserved
|
||||
|
||||
Permission is hereby granted, without written agreement and without
|
||||
|
|
@ -36,7 +36,7 @@
|
|||
*************************************************************************/
|
||||
#include <stdlib.h>
|
||||
#include "kernel.h"
|
||||
#include "bvec.h"
|
||||
#include "bvecx.h"
|
||||
|
||||
#define DEFAULT(v) { v.bitnum=0; v.bitvec=NULL; }
|
||||
|
||||
|
|
@ -47,7 +47,7 @@ static bvec bvec_build(int bitnum, int isTrue)
|
|||
{
|
||||
bvec vec;
|
||||
int n;
|
||||
|
||||
|
||||
vec.bitvec = NEW(BDD,bitnum);
|
||||
vec.bitnum = bitnum;
|
||||
if (!vec.bitvec)
|
||||
|
|
@ -94,7 +94,7 @@ bvec bvec_copy(bvec src)
|
|||
{
|
||||
bvec dst;
|
||||
int n;
|
||||
|
||||
|
||||
if (src.bitnum == 0)
|
||||
{
|
||||
DEFAULT(dst);
|
||||
|
|
@ -102,7 +102,7 @@ bvec bvec_copy(bvec src)
|
|||
}
|
||||
|
||||
dst = bvec_build(src.bitnum,0);
|
||||
|
||||
|
||||
for (n=0 ; n<src.bitnum ; n++)
|
||||
dst.bitvec[n] = bdd_addref( src.bitvec[n] );
|
||||
dst.bitnum = src.bitnum;
|
||||
|
|
@ -191,7 +191,7 @@ bvec bvec_var(int bitnum, int offset, int step)
|
|||
int n;
|
||||
|
||||
v = bvec_build(bitnum,0);
|
||||
|
||||
|
||||
for (n=0 ; n<bitnum ; n++)
|
||||
v.bitvec[n] = bdd_ithvar(offset+n*step);
|
||||
|
||||
|
|
@ -222,9 +222,9 @@ bvec bvec_varfdd(int var)
|
|||
DEFAULT(v);
|
||||
return v;
|
||||
}
|
||||
|
||||
|
||||
v = bvec_build(varbitnum,0);
|
||||
|
||||
|
||||
for (n=0 ; n<v.bitnum ; n++)
|
||||
v.bitvec[n] = bdd_ithvar(bddvar[n]);
|
||||
|
||||
|
|
@ -248,7 +248,7 @@ bvec bvec_varvec(int bitnum, int *var)
|
|||
int n;
|
||||
|
||||
v = bvec_build(bitnum,0);
|
||||
|
||||
|
||||
for (n=0 ; n<bitnum ; n++)
|
||||
v.bitvec[n] = bdd_ithvar(var[n]);
|
||||
|
||||
|
|
@ -413,7 +413,7 @@ bvec bvec_map1(bvec a, BDD (*fun)(BDD))
|
|||
{
|
||||
bvec res;
|
||||
int n;
|
||||
|
||||
|
||||
res = bvec_build(a.bitnum,0);
|
||||
for (n=0 ; n < a.bitnum ; n++)
|
||||
res.bitvec[n] = bdd_addref( fun(a.bitvec[n]) );
|
||||
|
|
@ -450,7 +450,7 @@ bvec bvec_map2(bvec a, bvec b, BDD (*fun)(BDD,BDD))
|
|||
bdd_error(BVEC_SIZE);
|
||||
return res;
|
||||
}
|
||||
|
||||
|
||||
res = bvec_build(a.bitnum,0);
|
||||
for (n=0 ; n < a.bitnum ; n++)
|
||||
res.bitvec[n] = bdd_addref( fun(a.bitvec[n], b.bitvec[n]) );
|
||||
|
|
@ -487,7 +487,7 @@ bvec bvec_map3(bvec a, bvec b, bvec c, BDD (*fun)(BDD,BDD,BDD))
|
|||
bdd_error(BVEC_SIZE);
|
||||
return res;
|
||||
}
|
||||
|
||||
|
||||
res = bvec_build(a.bitnum,0);
|
||||
for (n=0 ; n < a.bitnum ; n++)
|
||||
res.bitvec[n] = bdd_addref( fun(a.bitvec[n], b.bitvec[n], c.bitvec[n]) );
|
||||
|
|
@ -527,16 +527,16 @@ bvec bvec_add(bvec l, bvec r)
|
|||
DEFAULT(res);
|
||||
return res;
|
||||
}
|
||||
|
||||
|
||||
if (l.bitnum != r.bitnum)
|
||||
{
|
||||
bdd_error(BVEC_SIZE);
|
||||
DEFAULT(res);
|
||||
return res;
|
||||
}
|
||||
|
||||
|
||||
res = bvec_build(l.bitnum,0);
|
||||
|
||||
|
||||
for (n=0 ; n<res.bitnum ; n++)
|
||||
{
|
||||
BDD tmp1, tmp2, tmp3;
|
||||
|
|
@ -551,18 +551,18 @@ bvec bvec_add(bvec l, bvec r)
|
|||
tmp1 = bdd_addref( bdd_apply(l.bitvec[n], r.bitvec[n], bddop_or) );
|
||||
tmp2 = bdd_addref( bdd_apply(c, tmp1, bddop_and) );
|
||||
bdd_delref(tmp1);
|
||||
|
||||
|
||||
tmp1 = bdd_addref( bdd_apply(l.bitvec[n], r.bitvec[n], bddop_and) );
|
||||
tmp3 = bdd_addref( bdd_apply(tmp1, tmp2, bddop_or) );
|
||||
bdd_delref(tmp1);
|
||||
bdd_delref(tmp2);
|
||||
|
||||
|
||||
bdd_delref(c);
|
||||
c = tmp3;
|
||||
}
|
||||
|
||||
bdd_delref(c);
|
||||
|
||||
|
||||
return res;
|
||||
}
|
||||
|
||||
|
|
@ -596,16 +596,16 @@ bvec bvec_sub(bvec l, bvec r)
|
|||
DEFAULT(res);
|
||||
return res;
|
||||
}
|
||||
|
||||
|
||||
if (l.bitnum != r.bitnum)
|
||||
{
|
||||
bdd_error(BVEC_SIZE);
|
||||
DEFAULT(res);
|
||||
return res;
|
||||
}
|
||||
|
||||
|
||||
res = bvec_build(l.bitnum,0);
|
||||
|
||||
|
||||
for (n=0 ; n<res.bitnum ; n++)
|
||||
{
|
||||
BDD tmp1, tmp2, tmp3;
|
||||
|
|
@ -620,7 +620,7 @@ bvec bvec_sub(bvec l, bvec r)
|
|||
tmp1 = bdd_addref( bdd_apply(r.bitvec[n], c, bddop_or) );
|
||||
tmp2 = bdd_addref( bdd_apply(l.bitvec[n], tmp1, bddop_less) );
|
||||
bdd_delref(tmp1);
|
||||
|
||||
|
||||
tmp1 = bdd_addref( bdd_apply(l.bitvec[n], r.bitvec[n], bddop_and) );
|
||||
tmp3 = bdd_addref( bdd_apply(tmp1, c, bddop_and) );
|
||||
bdd_delref(tmp1);
|
||||
|
|
@ -628,13 +628,13 @@ bvec bvec_sub(bvec l, bvec r)
|
|||
tmp1 = bdd_addref( bdd_apply(tmp3, tmp2, bddop_or) );
|
||||
bdd_delref(tmp2);
|
||||
bdd_delref(tmp3);
|
||||
|
||||
|
||||
bdd_delref(c);
|
||||
c = tmp1;
|
||||
}
|
||||
|
||||
bdd_delref(c);
|
||||
|
||||
|
||||
return res;
|
||||
}
|
||||
|
||||
|
|
@ -659,17 +659,17 @@ bvec bvec_mulfixed(bvec e, int c)
|
|||
DEFAULT(res);
|
||||
return res;
|
||||
}
|
||||
|
||||
|
||||
if (c == 0)
|
||||
return bvec_build(e.bitnum,0); /* return false array (base case) */
|
||||
|
||||
next = bvec_build(e.bitnum,0);
|
||||
for (n=1 ; n<e.bitnum ; n++)
|
||||
/* e[] is never deleted, so no ref.cou. */
|
||||
next.bitvec[n] = e.bitvec[n-1];
|
||||
|
||||
next.bitvec[n] = e.bitvec[n-1];
|
||||
|
||||
rest = bvec_mulfixed(next, c>>1);
|
||||
|
||||
|
||||
if (c & 0x1)
|
||||
{
|
||||
res = bvec_add(e, rest);
|
||||
|
|
@ -711,10 +711,10 @@ bvec bvec_mul(bvec left, bvec right)
|
|||
res = bvec_false(bitnum);
|
||||
leftshifttmp = bvec_copy(left);
|
||||
leftshift = bvec_coerce(bitnum, leftshifttmp);
|
||||
|
||||
|
||||
/*bvec_delref(leftshifttmp);*/
|
||||
bvec_free(leftshifttmp);
|
||||
|
||||
|
||||
for (n=0 ; n<right.bitnum ; n++)
|
||||
{
|
||||
bvec added = bvec_add(res, leftshift);
|
||||
|
|
@ -733,14 +733,14 @@ bvec bvec_mul(bvec left, bvec right)
|
|||
for (m=bitnum-1 ; m>=1 ; m--)
|
||||
leftshift.bitvec[m] = leftshift.bitvec[m-1];
|
||||
leftshift.bitvec[0] = bddfalse;
|
||||
|
||||
|
||||
/*bvec_delref(added);*/
|
||||
bvec_free(added);
|
||||
}
|
||||
|
||||
/*bvec_delref(leftshift);*/
|
||||
bvec_free(leftshift);
|
||||
|
||||
|
||||
return res;
|
||||
}
|
||||
|
||||
|
|
@ -760,12 +760,12 @@ static void bvec_div_rec(bvec divisor, bvec *remainder, bvec *result, int step)
|
|||
|
||||
if (step > 1)
|
||||
bvec_div_rec( divisor, &newRemainder, &newResult, step-1 );
|
||||
|
||||
|
||||
bvec_free(tmp);
|
||||
bvec_free(sub);
|
||||
bvec_free(zero);
|
||||
bdd_delref(isSmaller);
|
||||
|
||||
|
||||
bvec_free(*remainder);
|
||||
bvec_free(*result);
|
||||
*result = newResult;
|
||||
|
|
@ -796,17 +796,17 @@ int bvec_divfixed(bvec e, int c, bvec *res, bvec *rem)
|
|||
bvec tmpremainder = bvec_shlfixed(tmp, 1, e.bitvec[e.bitnum-1]);
|
||||
bvec result = bvec_shlfixed(e, 1, bddfalse);
|
||||
bvec remainder;
|
||||
|
||||
|
||||
bvec_div_rec(divisor, &tmpremainder, &result, divisor.bitnum);
|
||||
remainder = bvec_shrfixed(tmpremainder, 1, bddfalse);
|
||||
|
||||
bvec_free(tmp);
|
||||
bvec_free(tmpremainder);
|
||||
bvec_free(divisor);
|
||||
|
||||
|
||||
*res = result;
|
||||
*rem = remainder;
|
||||
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
|
@ -899,7 +899,7 @@ int bvec_div(bvec left, bvec right, bvec *result, bvec *remainder)
|
|||
|
||||
/*bvec_delref(rem);*/
|
||||
bvec_free(rem);
|
||||
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
|
@ -931,7 +931,7 @@ bvec bvec_ite(bdd a, bvec b, bvec c)
|
|||
}
|
||||
|
||||
res = bvec_build(b.bitnum, 0);
|
||||
|
||||
|
||||
for (n=0 ; n<b.bitnum ; ++n)
|
||||
{
|
||||
res.bitvec[n] = bdd_addref( bdd_ite(a, b.bitvec[n], c.bitvec[n]) );
|
||||
|
|
@ -963,21 +963,21 @@ bvec bvec_shlfixed(bvec e, int pos, BDD c)
|
|||
DEFAULT(res);
|
||||
return res;
|
||||
}
|
||||
|
||||
|
||||
if (e.bitnum == 0)
|
||||
{
|
||||
DEFAULT(res);
|
||||
return res;
|
||||
}
|
||||
|
||||
|
||||
res = bvec_build(e.bitnum,0);
|
||||
|
||||
for (n=0 ; n<minnum ; n++)
|
||||
res.bitvec[n] = bdd_addref(c);
|
||||
|
||||
|
||||
for (n=minnum ; n<e.bitnum ; n++)
|
||||
res.bitvec[n] = bdd_addref(e.bitvec[n-pos]);
|
||||
|
||||
|
||||
return res;
|
||||
}
|
||||
|
||||
|
|
@ -1005,14 +1005,14 @@ BVEC bvec_shl(BVEC l, BVEC r, BDD c)
|
|||
DEFAULT(res);
|
||||
return res;
|
||||
}
|
||||
|
||||
|
||||
res = bvec_build(l.bitnum, 0);
|
||||
|
||||
for (n=0 ; n<=l.bitnum ; n++)
|
||||
{
|
||||
val = bvec_con(r.bitnum, n);
|
||||
rEquN = bdd_addref( bvec_equ(r, val) );
|
||||
|
||||
|
||||
for (m=0 ; m<l.bitnum ; m++)
|
||||
{
|
||||
/* Set the m'th new location to be the (m+n)'th old location */
|
||||
|
|
@ -1040,7 +1040,7 @@ BVEC bvec_shl(BVEC l, BVEC r, BDD c)
|
|||
for (m=0 ; m<l.bitnum ; m++)
|
||||
{
|
||||
tmp2 = bdd_addref( bdd_or(res.bitvec[m], tmp1) );
|
||||
|
||||
|
||||
bdd_delref(res.bitvec[m]);
|
||||
res.bitvec[m] = tmp2;
|
||||
}
|
||||
|
|
@ -1049,7 +1049,7 @@ BVEC bvec_shl(BVEC l, BVEC r, BDD c)
|
|||
bdd_delref(rEquN);
|
||||
/*bvec_delref(val);*/
|
||||
bvec_free(val);
|
||||
|
||||
|
||||
return res;
|
||||
}
|
||||
|
||||
|
|
@ -1068,25 +1068,25 @@ bvec bvec_shrfixed(bvec e, int pos, BDD c)
|
|||
{
|
||||
bvec res;
|
||||
int n, maxnum = MAX(0,e.bitnum-pos);
|
||||
|
||||
|
||||
if (pos < 0)
|
||||
{
|
||||
bdd_error(BVEC_SHIFT);
|
||||
DEFAULT(res);
|
||||
return res;
|
||||
}
|
||||
|
||||
|
||||
if (e.bitnum == 0)
|
||||
{
|
||||
DEFAULT(res);
|
||||
return res;
|
||||
}
|
||||
|
||||
|
||||
res = bvec_build(e.bitnum,0);
|
||||
|
||||
for (n=maxnum ; n<e.bitnum ; n++)
|
||||
res.bitvec[n] = bdd_addref(c);
|
||||
|
||||
|
||||
for (n=0 ; n<maxnum ; n++)
|
||||
res.bitvec[n] = bdd_addref(e.bitvec[n+pos]);
|
||||
|
||||
|
|
@ -1117,14 +1117,14 @@ BVEC bvec_shr(BVEC l, BVEC r, BDD c)
|
|||
DEFAULT(res);
|
||||
return res;
|
||||
}
|
||||
|
||||
|
||||
res = bvec_build(l.bitnum, 0);
|
||||
|
||||
for (n=0 ; n<=l.bitnum ; n++)
|
||||
{
|
||||
val = bvec_con(r.bitnum, n);
|
||||
rEquN = bdd_addref( bvec_equ(r, val) );
|
||||
|
||||
|
||||
for (m=0 ; m<l.bitnum ; m++)
|
||||
{
|
||||
/* Set the m'th new location to be the (m+n)'th old location */
|
||||
|
|
@ -1152,7 +1152,7 @@ BVEC bvec_shr(BVEC l, BVEC r, BDD c)
|
|||
for (m=0 ; m<l.bitnum ; m++)
|
||||
{
|
||||
tmp2 = bdd_addref( bdd_or(res.bitvec[m], tmp1) );
|
||||
|
||||
|
||||
bdd_delref(res.bitvec[m]);
|
||||
res.bitvec[m] = tmp2;
|
||||
}
|
||||
|
|
@ -1161,7 +1161,7 @@ BVEC bvec_shr(BVEC l, BVEC r, BDD c)
|
|||
bdd_delref(rEquN);
|
||||
/*bvec_delref(val);*/
|
||||
bvec_free(val);
|
||||
|
||||
|
||||
return res;
|
||||
}
|
||||
|
||||
|
|
@ -1180,21 +1180,21 @@ bdd bvec_lth(bvec l, bvec r)
|
|||
{
|
||||
BDD p = bddfalse;
|
||||
int n;
|
||||
|
||||
|
||||
if (l.bitnum == 0 || r.bitnum == 0)
|
||||
return bddfalse;
|
||||
|
||||
|
||||
if (l.bitnum != r.bitnum)
|
||||
{
|
||||
bdd_error(BVEC_SIZE);
|
||||
return p;
|
||||
}
|
||||
|
||||
|
||||
for (n=0 ; n<l.bitnum ; n++)
|
||||
{
|
||||
/* p = (!l[n] & r[n]) |
|
||||
* bdd_apply(l[n], r[n], bddop_biimp) & p; */
|
||||
|
||||
|
||||
BDD tmp1 = bdd_addref(bdd_apply(l.bitvec[n],r.bitvec[n],bddop_less));
|
||||
BDD tmp2 = bdd_addref(bdd_apply(l.bitvec[n],r.bitvec[n],bddop_biimp));
|
||||
BDD tmp3 = bdd_addref( bdd_apply(tmp2, p, bddop_and) );
|
||||
|
|
@ -1224,21 +1224,21 @@ bdd bvec_lte(bvec l, bvec r)
|
|||
{
|
||||
BDD p = bddtrue;
|
||||
int n;
|
||||
|
||||
|
||||
if (l.bitnum == 0 || r.bitnum == 0)
|
||||
return bddfalse;
|
||||
|
||||
|
||||
if (l.bitnum != r.bitnum)
|
||||
{
|
||||
bdd_error(BVEC_SIZE);
|
||||
return p;
|
||||
}
|
||||
|
||||
|
||||
for (n=0 ; n<l.bitnum ; n++)
|
||||
{
|
||||
/* p = (!l[n] & r[n]) |
|
||||
* bdd_apply(l[n], r[n], bddop_biimp) & p; */
|
||||
|
||||
|
||||
BDD tmp1 = bdd_addref( bdd_apply(l.bitvec[n], r.bitvec[n], bddop_less) );
|
||||
BDD tmp2 = bdd_addref( bdd_apply(l.bitvec[n], r.bitvec[n], bddop_biimp) );
|
||||
BDD tmp3 = bdd_addref( bdd_apply(tmp2, p, bddop_and) );
|
||||
|
|
@ -1306,16 +1306,16 @@ bdd bvec_equ(bvec l, bvec r)
|
|||
{
|
||||
BDD p = bddtrue;
|
||||
int n;
|
||||
|
||||
|
||||
if (l.bitnum == 0 || r.bitnum == 0)
|
||||
return bddfalse;
|
||||
|
||||
|
||||
if (l.bitnum != r.bitnum)
|
||||
{
|
||||
bdd_error(BVEC_SIZE);
|
||||
return p;
|
||||
}
|
||||
|
||||
|
||||
for (n=0 ; n<l.bitnum ; n++)
|
||||
{
|
||||
BDD tmp1, tmp2;
|
||||
|
|
|
|||
|
|
@ -35,10 +35,10 @@
|
|||
DATE: (C) may 1999
|
||||
*************************************************************************/
|
||||
|
||||
#ifndef _BVEC_H
|
||||
#define _BVEC_H
|
||||
#ifndef _BVECX_H
|
||||
#define _BVECX_H
|
||||
|
||||
#include "fdd.h"
|
||||
#include "fddx.h"
|
||||
|
||||
/* Boolean (BDD) vector */
|
||||
/*
|
||||
|
|
@ -295,6 +295,6 @@ inline bdd bvec_neq(const bvec &left, const bvec &right)
|
|||
|
||||
#endif /* CPLUSPLUS */
|
||||
|
||||
#endif /* _BVEC_H */
|
||||
#endif /* _BVECX_H */
|
||||
|
||||
/* EOF */
|
||||
|
|
@ -38,7 +38,7 @@
|
|||
#include <stdlib.h>
|
||||
#include <iomanip>
|
||||
#include "kernel.h"
|
||||
#include "bvec.h"
|
||||
#include "bvecx.h"
|
||||
|
||||
using namespace std;
|
||||
|
||||
|
|
|
|||
114
buddy/src/fdd.c
114
buddy/src/fdd.c
|
|
@ -39,7 +39,7 @@
|
|||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include "kernel.h"
|
||||
#include "fdd.h"
|
||||
#include "fddx.h"
|
||||
|
||||
|
||||
static void fdd_printset_rec(FILE *, int, int *);
|
||||
|
|
@ -83,7 +83,7 @@ void bdd_fdd_init(void)
|
|||
void bdd_fdd_done(void)
|
||||
{
|
||||
int n;
|
||||
|
||||
|
||||
if (domain != NULL)
|
||||
{
|
||||
for (n=0 ; n<fdvarnum ; n++)
|
||||
|
|
@ -129,7 +129,7 @@ int fdd_extdomain(int *dom, int num)
|
|||
|
||||
if (!bddrunning)
|
||||
return bdd_error(BDD_RUNNING);
|
||||
|
||||
|
||||
/* Build domain table */
|
||||
if (domain == NULL) /* First time */
|
||||
{
|
||||
|
|
@ -142,7 +142,7 @@ int fdd_extdomain(int *dom, int num)
|
|||
if (fdvarnum + num > fdvaralloc)
|
||||
{
|
||||
fdvaralloc += (num > fdvaralloc) ? num : fdvaralloc;
|
||||
|
||||
|
||||
domain = (Domain*)realloc(domain, sizeof(Domain)*fdvaralloc);
|
||||
if (domain == NULL)
|
||||
return bdd_error(BDD_MEMORY);
|
||||
|
|
@ -182,7 +182,7 @@ int fdd_extdomain(int *dom, int num)
|
|||
|
||||
fdvarnum += num;
|
||||
firstbddvar += extravars;
|
||||
|
||||
|
||||
return offset;
|
||||
}
|
||||
|
||||
|
|
@ -208,17 +208,17 @@ int fdd_overlapdomain(int v1, int v2)
|
|||
{
|
||||
Domain *d;
|
||||
int n;
|
||||
|
||||
|
||||
if (!bddrunning)
|
||||
return bdd_error(BDD_RUNNING);
|
||||
|
||||
|
||||
if (v1 < 0 || v1 >= fdvarnum || v2 < 0 || v2 >= fdvarnum)
|
||||
return bdd_error(BDD_VAR);
|
||||
|
||||
if (fdvarnum + 1 > fdvaralloc)
|
||||
{
|
||||
fdvaralloc += fdvaralloc;
|
||||
|
||||
|
||||
domain = (Domain*)realloc(domain, sizeof(Domain)*fdvaralloc);
|
||||
if (domain == NULL)
|
||||
return bdd_error(BDD_MEMORY);
|
||||
|
|
@ -233,10 +233,10 @@ int fdd_overlapdomain(int v1, int v2)
|
|||
d->ivar[n] = domain[v1].ivar[n];
|
||||
for (n=0 ; n<domain[v2].binsize ; n++)
|
||||
d->ivar[domain[v1].binsize+n] = domain[v2].ivar[n];
|
||||
|
||||
|
||||
d->var = bdd_makeset(d->ivar, d->binsize);
|
||||
bdd_addref(d->var);
|
||||
|
||||
|
||||
return fdvarnum++;
|
||||
}
|
||||
|
||||
|
|
@ -275,7 +275,7 @@ int fdd_domainnum(void)
|
|||
{
|
||||
if (!bddrunning)
|
||||
return bdd_error(BDD_RUNNING);
|
||||
|
||||
|
||||
return fdvarnum;
|
||||
}
|
||||
|
||||
|
|
@ -294,7 +294,7 @@ int fdd_domainsize(int v)
|
|||
{
|
||||
if (!bddrunning)
|
||||
return bdd_error(BDD_RUNNING);
|
||||
|
||||
|
||||
if (v < 0 || v >= fdvarnum)
|
||||
return bdd_error(BDD_VAR);
|
||||
return domain[v].realsize;
|
||||
|
|
@ -315,7 +315,7 @@ int fdd_varnum(int v)
|
|||
{
|
||||
if (!bddrunning)
|
||||
return bdd_error(BDD_RUNNING);
|
||||
|
||||
|
||||
if (v >= fdvarnum || v < 0)
|
||||
return bdd_error(BDD_VAR);
|
||||
return domain[v].binsize;
|
||||
|
|
@ -343,7 +343,7 @@ int *fdd_vars(int v)
|
|||
bdd_error(BDD_RUNNING);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
|
||||
if (v >= fdvarnum || v < 0)
|
||||
{
|
||||
bdd_error(BDD_VAR);
|
||||
|
|
@ -378,13 +378,13 @@ BDD fdd_ithvar(int var, int val)
|
|||
{
|
||||
int n;
|
||||
int v=1, tmp;
|
||||
|
||||
|
||||
if (!bddrunning)
|
||||
{
|
||||
bdd_error(BDD_RUNNING);
|
||||
return bddfalse;
|
||||
}
|
||||
|
||||
|
||||
if (var < 0 || var >= fdvarnum)
|
||||
{
|
||||
bdd_error(BDD_VAR);
|
||||
|
|
@ -400,7 +400,7 @@ BDD fdd_ithvar(int var, int val)
|
|||
for (n=0 ; n<domain[var].binsize ; n++)
|
||||
{
|
||||
bdd_addref(v);
|
||||
|
||||
|
||||
if (val & 0x1)
|
||||
tmp = bdd_apply(bdd_ithvar(domain[var].ivar[n]), v, bddop_and);
|
||||
else
|
||||
|
|
@ -465,11 +465,11 @@ int* fdd_scanallvar(BDD r)
|
|||
char *store;
|
||||
int *res;
|
||||
BDD p = r;
|
||||
|
||||
|
||||
CHECKa(r,NULL);
|
||||
if (r == bddfalse)
|
||||
return NULL;
|
||||
|
||||
|
||||
store = NEW(char,bddvarnum);
|
||||
for (n=0 ; n<bddvarnum ; n++)
|
||||
store[n] = 0;
|
||||
|
|
@ -494,21 +494,21 @@ int* fdd_scanallvar(BDD r)
|
|||
{
|
||||
int m;
|
||||
int val=0;
|
||||
|
||||
|
||||
for (m=domain[n].binsize-1 ; m>=0 ; m--)
|
||||
if ( store[domain[n].ivar[m]] )
|
||||
val = val*2 + 1;
|
||||
else
|
||||
val = val*2;
|
||||
|
||||
|
||||
res[n] = val;
|
||||
}
|
||||
|
||||
|
||||
free(store);
|
||||
|
||||
|
||||
return res;
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
NAME {* fdd\_ithset *}
|
||||
SECTION {* fdd *}
|
||||
|
|
@ -526,7 +526,7 @@ BDD fdd_ithset(int var)
|
|||
bdd_error(BDD_RUNNING);
|
||||
return bddfalse;
|
||||
}
|
||||
|
||||
|
||||
if (var < 0 || var >= fdvarnum)
|
||||
{
|
||||
bdd_error(BDD_VAR);
|
||||
|
|
@ -553,13 +553,13 @@ BDD fdd_domain(int var)
|
|||
int n,val;
|
||||
Domain *dom;
|
||||
BDD d;
|
||||
|
||||
|
||||
if (!bddrunning)
|
||||
{
|
||||
bdd_error(BDD_RUNNING);
|
||||
return bddfalse;
|
||||
}
|
||||
|
||||
|
||||
if (var < 0 || var >= fdvarnum)
|
||||
{
|
||||
bdd_error(BDD_VAR);
|
||||
|
|
@ -567,15 +567,15 @@ BDD fdd_domain(int var)
|
|||
}
|
||||
|
||||
/* Encode V<=X-1. V is the variables in 'var' and X is the domain size */
|
||||
|
||||
|
||||
dom = &domain[var];
|
||||
val = dom->realsize-1;
|
||||
d = bddtrue;
|
||||
|
||||
|
||||
for (n=0 ; n<dom->binsize ; n++)
|
||||
{
|
||||
BDD tmp;
|
||||
|
||||
|
||||
if (val & 0x1)
|
||||
tmp = bdd_apply( bdd_nithvar(dom->ivar[n]), d, bddop_or );
|
||||
else
|
||||
|
|
@ -607,13 +607,13 @@ BDD fdd_equals(int left, int right)
|
|||
{
|
||||
BDD e = bddtrue, tmp1, tmp2;
|
||||
int n;
|
||||
|
||||
|
||||
if (!bddrunning)
|
||||
{
|
||||
bdd_error(BDD_RUNNING);
|
||||
return bddfalse;
|
||||
}
|
||||
|
||||
|
||||
if (left < 0 || left >= fdvarnum || right < 0 || right >= fdvarnum)
|
||||
{
|
||||
bdd_error(BDD_VAR);
|
||||
|
|
@ -624,13 +624,13 @@ BDD fdd_equals(int left, int right)
|
|||
bdd_error(BDD_RANGE);
|
||||
return bddfalse;
|
||||
}
|
||||
|
||||
|
||||
for (n=0 ; n<domain[left].binsize ; n++)
|
||||
{
|
||||
tmp1 = bdd_addref( bdd_apply(bdd_ithvar(domain[left].ivar[n]),
|
||||
bdd_ithvar(domain[right].ivar[n]),
|
||||
bddop_biimp) );
|
||||
|
||||
|
||||
tmp2 = bdd_addref( bdd_apply(e, tmp1, bddop_and) );
|
||||
bdd_delref(tmp1);
|
||||
bdd_delref(e);
|
||||
|
|
@ -704,13 +704,13 @@ void fdd_printset(BDD r)
|
|||
void fdd_fprintset(FILE *ofile, BDD r)
|
||||
{
|
||||
int *set;
|
||||
|
||||
|
||||
if (!bddrunning)
|
||||
{
|
||||
bdd_error(BDD_RUNNING);
|
||||
return;
|
||||
}
|
||||
|
||||
|
||||
if (r < 2)
|
||||
{
|
||||
fprintf(ofile, "%s", r == 0 ? "F" : "T");
|
||||
|
|
@ -723,7 +723,7 @@ void fdd_fprintset(FILE *ofile, BDD r)
|
|||
bdd_error(BDD_MEMORY);
|
||||
return;
|
||||
}
|
||||
|
||||
|
||||
memset(set, 0, sizeof(int) * bddvarnum);
|
||||
fdd_printset_rec(ofile, r, set);
|
||||
free(set);
|
||||
|
|
@ -737,7 +737,7 @@ static void fdd_printset_rec(FILE *ofile, int r, int *set)
|
|||
int *var;
|
||||
int *binval;
|
||||
int ok, first;
|
||||
|
||||
|
||||
if (r == 0)
|
||||
return;
|
||||
else
|
||||
|
|
@ -754,7 +754,7 @@ static void fdd_printset_rec(FILE *ofile, int r, int *set)
|
|||
for (m=0 ; m<domain[n].binsize ; m++)
|
||||
if (set[domain[n].ivar[m]] != 0)
|
||||
used = 1;
|
||||
|
||||
|
||||
if (used)
|
||||
{
|
||||
if (!first)
|
||||
|
|
@ -767,12 +767,12 @@ static void fdd_printset_rec(FILE *ofile, int r, int *set)
|
|||
printf(":");
|
||||
|
||||
var = domain[n].ivar;
|
||||
|
||||
|
||||
for (m=0 ; m<(1<<domain[n].binsize) ; m++)
|
||||
{
|
||||
binval = fdddec2bin(n, m);
|
||||
ok=1;
|
||||
|
||||
|
||||
for (i=0 ; i<domain[n].binsize && ok ; i++)
|
||||
if (set[var[i]] == 1 && binval[i] != 0)
|
||||
ok = 0;
|
||||
|
|
@ -800,10 +800,10 @@ static void fdd_printset_rec(FILE *ofile, int r, int *set)
|
|||
{
|
||||
set[bddlevel2var[LEVEL(r)]] = 1;
|
||||
fdd_printset_rec(ofile, LOW(r), set);
|
||||
|
||||
|
||||
set[bddlevel2var[LEVEL(r)]] = 2;
|
||||
fdd_printset_rec(ofile, HIGH(r), set);
|
||||
|
||||
|
||||
set[bddlevel2var[LEVEL(r)]] = 0;
|
||||
}
|
||||
}
|
||||
|
|
@ -828,17 +828,17 @@ int fdd_scanset(BDD r, int **varset, int *varnum)
|
|||
{
|
||||
int *fv, fn;
|
||||
int num,n,m,i;
|
||||
|
||||
|
||||
if (!bddrunning)
|
||||
return bdd_error(BDD_RUNNING);
|
||||
|
||||
|
||||
if ((n=bdd_scanset(r, &fv, &fn)) < 0)
|
||||
return n;
|
||||
|
||||
for (n=0,num=0 ; n<fdvarnum ; n++)
|
||||
{
|
||||
int found=0;
|
||||
|
||||
|
||||
for (m=0 ; m<domain[n].binsize && !found ; m++)
|
||||
{
|
||||
for (i=0 ; i<fn && !found ; i++)
|
||||
|
|
@ -856,7 +856,7 @@ int fdd_scanset(BDD r, int **varset, int *varnum)
|
|||
for (n=0,num=0 ; n<fdvarnum ; n++)
|
||||
{
|
||||
int found=0;
|
||||
|
||||
|
||||
for (m=0 ; m<domain[n].binsize && !found ; m++)
|
||||
{
|
||||
for (i=0 ; i<fn && !found ; i++)
|
||||
|
|
@ -897,14 +897,14 @@ BDD fdd_makeset(int *varset, int varnum)
|
|||
bdd_error(BDD_RUNNING);
|
||||
return bddfalse;
|
||||
}
|
||||
|
||||
|
||||
for (n=0 ; n<varnum ; n++)
|
||||
if (varset[n] < 0 || varset[n] >= fdvarnum)
|
||||
{
|
||||
bdd_error(BDD_VAR);
|
||||
return bddfalse;
|
||||
}
|
||||
|
||||
|
||||
for (n=0 ; n<varnum ; n++)
|
||||
{
|
||||
bdd_addref(res);
|
||||
|
|
@ -932,10 +932,10 @@ int fdd_intaddvarblock(int first, int last, int fixed)
|
|||
{
|
||||
bdd res = bddtrue, tmp;
|
||||
int n, err;
|
||||
|
||||
|
||||
if (!bddrunning)
|
||||
return bdd_error(BDD_RUNNING);
|
||||
|
||||
|
||||
if (first > last || first < 0 || last >= fdvarnum)
|
||||
return bdd_error(BDD_VARBLK);
|
||||
|
||||
|
|
@ -948,7 +948,7 @@ int fdd_intaddvarblock(int first, int last, int fixed)
|
|||
}
|
||||
|
||||
err = bdd_addvarblock(res, fixed);
|
||||
|
||||
|
||||
bdd_delref(res);
|
||||
return err;
|
||||
}
|
||||
|
|
@ -972,10 +972,10 @@ int fdd_setpair(bddPair *pair, int p1, int p2)
|
|||
|
||||
if (!bddrunning)
|
||||
return bdd_error(BDD_RUNNING);
|
||||
|
||||
|
||||
if (p1<0 || p1>=fdvarnum || p2<0 || p2>=fdvarnum)
|
||||
return bdd_error(BDD_VAR);
|
||||
|
||||
|
||||
if (domain[p1].binsize != domain[p2].binsize)
|
||||
return bdd_error(BDD_VARNUM);
|
||||
|
||||
|
|
@ -1006,11 +1006,11 @@ int fdd_setpairs(bddPair *pair, int *p1, int *p2, int size)
|
|||
|
||||
if (!bddrunning)
|
||||
return bdd_error(BDD_RUNNING);
|
||||
|
||||
|
||||
for (n=0 ; n<size ; n++)
|
||||
if (p1[n]<0 || p1[n]>=fdvarnum || p2[n]<0 || p2[n]>=fdvarnum)
|
||||
return bdd_error(BDD_VAR);
|
||||
|
||||
|
||||
for (n=0 ; n<size ; n++)
|
||||
if ((e=fdd_setpair(pair, p1[n], p2[n])) < 0)
|
||||
return e;
|
||||
|
|
@ -1033,7 +1033,7 @@ static void Domain_done(Domain* d)
|
|||
static void Domain_allocate(Domain* d, int range)
|
||||
{
|
||||
int calcsize = 2;
|
||||
|
||||
|
||||
if (range <= 0 || range > INT_MAX/2)
|
||||
{
|
||||
bdd_error(BDD_RANGE);
|
||||
|
|
|
|||
|
|
@ -35,10 +35,10 @@
|
|||
DATE: (C) february 1999
|
||||
*************************************************************************/
|
||||
|
||||
#ifndef _FDD_H
|
||||
#define _FDD_H
|
||||
#ifndef _FDDX_H
|
||||
#define _FDDX_H
|
||||
|
||||
#include "bdd.h"
|
||||
#include "bddx.h"
|
||||
|
||||
|
||||
#ifdef CPLUSPLUS
|
||||
|
|
@ -167,7 +167,7 @@ inline bdd fdd_neq(int bitnum, bdd *left, bdd *right)
|
|||
|
||||
#endif /* CPLUSPLUS */
|
||||
|
||||
#endif /* _FDD_H */
|
||||
#endif /* _FDDX_H */
|
||||
|
||||
|
||||
/* EOF */
|
||||
|
|
@ -37,7 +37,7 @@
|
|||
#ifndef _IMATRIX_H
|
||||
#define _IMATRIX_H
|
||||
|
||||
#include "bdd.h" /* for __purefn */
|
||||
#include "bddx.h" /* for __purefn */
|
||||
|
||||
typedef struct _imatrix
|
||||
{
|
||||
|
|
|
|||
|
|
@ -42,7 +42,7 @@
|
|||
|
||||
#include <limits.h>
|
||||
#include <setjmp.h>
|
||||
#include "bdd.h"
|
||||
#include "bddx.h"
|
||||
#ifdef HAVE_CONFIG_H
|
||||
# include "config.h"
|
||||
#endif
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue