#include "misc/util/util_hack.h"
#include "cuddInt.h"

Functions
static DdApaNumber	cuddApaCountMintermAux (DdNode node, int digits, DdApaNumber max, DdApaNumber min, st__table table)

static enum st__retval	cuddApaStCountfree (char key, char value, char *arg)

int	Cudd_ApaNumberOfDigits (int binaryDigits)

DdApaNumber	Cudd_NewApaNumber (int digits)

void	Cudd_ApaCopy (int digits, DdApaNumber source, DdApaNumber dest)

DdApaDigit	Cudd_ApaAdd (int digits, DdApaNumber a, DdApaNumber b, DdApaNumber sum)

DdApaDigit	Cudd_ApaSubtract (int digits, DdApaNumber a, DdApaNumber b, DdApaNumber diff)

DdApaDigit	Cudd_ApaShortDivision (int digits, DdApaNumber dividend, DdApaDigit divisor, DdApaNumber quotient)

unsigned int	Cudd_ApaIntDivision (int digits, DdApaNumber dividend, unsigned int divisor, DdApaNumber quotient)

void	Cudd_ApaShiftRight (int digits, DdApaDigit in, DdApaNumber a, DdApaNumber b)

void	Cudd_ApaSetToLiteral (int digits, DdApaNumber number, DdApaDigit literal)

void	Cudd_ApaPowerOfTwo (int digits, DdApaNumber number, int power)

int	Cudd_ApaCompare (int digitsFirst, DdApaNumber first, int digitsSecond, DdApaNumber second)

int	Cudd_ApaCompareRatios (int digitsFirst, DdApaNumber firstNum, unsigned int firstDen, int digitsSecond, DdApaNumber secondNum, unsigned int secondDen)

int	Cudd_ApaPrintHex (FILE *fp, int digits, DdApaNumber number)

int	Cudd_ApaPrintDecimal (FILE *fp, int digits, DdApaNumber number)

int	Cudd_ApaPrintExponential (FILE *fp, int digits, DdApaNumber number, int precision)

DdApaNumber	Cudd_ApaCountMinterm (DdManager manager, DdNode node, int nvars, int *digits)

int	Cudd_ApaPrintMinterm (FILE fp, DdManager dd, DdNode *node, int nvars)

int	Cudd_ApaPrintMintermExp (FILE fp, DdManager dd, DdNode *node, int nvars, int precision)

int	Cudd_ApaPrintDensity (FILE fp, DdManager dd, DdNode *node, int nvars)

Variables
static ABC_NAMESPACE_IMPL_START char rcsid[]	DD_UNUSED = "$Id: cuddApa.c,v 1.19 2009/03/08 01:27:50 fabio Exp $"

static DdNode *	background

static DdNode *	zero

Function Documentation

DdApaDigit Cudd_ApaAdd	(	int	digits,
		DdApaNumber	a,
		DdApaNumber	b,
		DdApaNumber	sum
	)

Function********************************************************************

Synopsis [Adds two arbitrary precision integers.]

Description [Adds two arbitrary precision integers. Returns the carry out of the most significant digit.]

SideEffects [The result of the sum is stored in parameter sum.]

SeeAlso []

Definition at line 221 of file cuddApa.c.

 {
     int i;
     DdApaDoubleDigit partial = 0;
 
     for (i = digits - 1; i >= 0; i--) {
         partial = a[i] + b[i] + DD_MSDIGIT(partial);
         sum[i] = (DdApaDigit) DD_LSDIGIT(partial);
     }
     return((DdApaDigit) DD_MSDIGIT(partial));
 
 } /* end of Cudd_ApaAdd */

int Cudd_ApaCompare	(	int	digitsFirst,
		DdApaNumber	first,
		int	digitsSecond,
		DdApaNumber	second
	)

Function********************************************************************

Synopsis [Compares two arbitrary precision integers.]

Description [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.]

SideEffects [None]

SeeAlso []

Definition at line 449 of file cuddApa.c.

 {
     int i;
     int firstNZ, secondNZ;
 
     /* Find first non-zero in both numbers. */
     for (firstNZ = 0; firstNZ < digitsFirst; firstNZ++)
         if (first[firstNZ] != 0) break;
     for (secondNZ = 0; secondNZ < digitsSecond; secondNZ++)
         if (second[secondNZ] != 0) break;
     if (digitsFirst - firstNZ > digitsSecond - secondNZ) return(1);
     else if (digitsFirst - firstNZ < digitsSecond - secondNZ) return(-1);
     for (i = 0; i < digitsFirst - firstNZ; i++) {
         if (first[firstNZ + i] > second[secondNZ + i]) return(1);
         else if (first[firstNZ + i] < second[secondNZ + i]) return(-1);
     }
     return(0);
 
 } /* end of Cudd_ApaCompare */

int Cudd_ApaCompareRatios	(	int	digitsFirst,
		DdApaNumber	firstNum,
		unsigned int	firstDen,
		int	digitsSecond,
		DdApaNumber	secondNum,
		unsigned int	secondDen
	)

Function********************************************************************

Synopsis [Compares the ratios of two arbitrary precision integers to two unsigned ints.]

Description [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.]

SideEffects [None]

SeeAlso []

Definition at line 489 of file cuddApa.c.

 {
     int result;
     DdApaNumber first, second;
     unsigned int firstRem, secondRem;
 
     first = Cudd_NewApaNumber(digitsFirst);
     firstRem = Cudd_ApaIntDivision(digitsFirst,firstNum,firstDen,first);
     second = Cudd_NewApaNumber(digitsSecond);
     secondRem = Cudd_ApaIntDivision(digitsSecond,secondNum,secondDen,second);
     result = Cudd_ApaCompare(digitsFirst,first,digitsSecond,second);
     ABC_FREE(first);
     ABC_FREE(second);
     if (result == 0) {
         if ((double)firstRem/firstDen > (double)secondRem/secondDen)
             return(1);
         else if ((double)firstRem/firstDen < (double)secondRem/secondDen)
             return(-1);
     }
     return(result);
 
 } /* end of Cudd_ApaCompareRatios */

void Cudd_ApaCopy	(	int	digits,
		DdApaNumber	source,
		DdApaNumber	dest
	)

Function********************************************************************

Synopsis [Makes a copy of an arbitrary precision integer.]

Description [Makes a copy of an arbitrary precision integer.]

SideEffects [Changes parameter dest.]

SeeAlso []

Definition at line 194 of file cuddApa.c.

 {
     int i;
 
     for (i = 0; i < digits; i++) {
         dest[i] = source[i];
     }
 
 } /* end of Cudd_ApaCopy */

DdApaNumber Cudd_ApaCountMinterm	(	DdManager *	manager,
		DdNode *	node,
		int	nvars,
		int *	digits
	)

Function********************************************************************

Synopsis [Counts the number of minterms of a DD.]

Description [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.]

SideEffects [The number of digits of the result is returned in parameter digits.]

SeeAlso [Cudd_CountMinterm]

Definition at line 684 of file cuddApa.c.

 {
     DdApaNumber max, min;
     st__table    *table;
     DdApaNumber i,count;
 
     background = manager->background;
     zero = Cudd_Not(manager->one);
 
     *digits = Cudd_ApaNumberOfDigits(nvars+1);
     max = Cudd_NewApaNumber(*digits);
     if (max == NULL) {
         return(NULL);
     }
     Cudd_ApaPowerOfTwo(*digits,max,nvars);
     min = Cudd_NewApaNumber(*digits);
     if (min == NULL) {
         ABC_FREE(max);
         return(NULL);
     }
     Cudd_ApaSetToLiteral(*digits,min,0);
     table = st__init_table( st__ptrcmp, st__ptrhash);
     if (table == NULL) {
         ABC_FREE(max);
         ABC_FREE(min);
         return(NULL);
     }
     i = cuddApaCountMintermAux(Cudd_Regular(node),*digits,max,min,table);
     if (i == NULL) {
         ABC_FREE(max);
         ABC_FREE(min);
         st__foreach(table, cuddApaStCountfree, NULL);
         st__free_table(table);
         return(NULL);
     }
     count = Cudd_NewApaNumber(*digits);
     if (count == NULL) {
         ABC_FREE(max);
         ABC_FREE(min);
         st__foreach(table, cuddApaStCountfree, NULL);
         st__free_table(table);
         if (Cudd_Regular(node)->ref == 1) ABC_FREE(i);
         return(NULL);
     }
     if (Cudd_IsComplement(node)) {
         (void) Cudd_ApaSubtract(*digits,max,i,count);
     } else {
         Cudd_ApaCopy(*digits,i,count);
     }
     ABC_FREE(max);
     ABC_FREE(min);
     st__foreach(table, cuddApaStCountfree, NULL);
     st__free_table(table);
     if (Cudd_Regular(node)->ref == 1) ABC_FREE(i);
     return(count);
 
 } /* end of Cudd_ApaCountMinterm */

unsigned int Cudd_ApaIntDivision	(	int	digits,
		DdApaNumber	dividend,
		unsigned int	divisor,
		DdApaNumber	quotient
	)

Function********************************************************************

Synopsis [Divides an arbitrary precision integer by an integer.]

Description [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.]

SideEffects [The quotient is returned in parameter quotient.]

SeeAlso [Cudd_ApaShortDivision]

Definition at line 324 of file cuddApa.c.

 {
     int i;
     double partial;
     unsigned int remainder = 0;
     double ddiv = (double) divisor;
 
     for (i = 0; i < digits; i++) {
         partial = (double) remainder * DD_APA_BASE + dividend[i];
         quotient[i] = (DdApaDigit) (partial / ddiv);
         remainder = (unsigned int) (partial - ((double)quotient[i] * ddiv));
     }
 
     return(remainder);
 
 } /* end of Cudd_ApaIntDivision */

int Cudd_ApaNumberOfDigits ( int binaryDigits )

AutomaticEnd Function********************************************************************

Synopsis [Finds the number of digits for an arbitrary precision integer.]

Description [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.]

SideEffects [None]

SeeAlso []

Definition at line 147 of file cuddApa.c.

 {
     int digits;
 
     digits = binaryDigits / DD_APA_BITS;
     if ((digits * DD_APA_BITS) != binaryDigits)
         digits++;
     return(digits);
 
 } /* end of Cudd_ApaNumberOfDigits */

void Cudd_ApaPowerOfTwo	(	int	digits,
		DdApaNumber	number,
		int	power
	)

Function********************************************************************

Synopsis [Sets an arbitrary precision integer to a power of two.]

Description [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.]

SideEffects [The result is returned in parameter number.]

SeeAlso []

Definition at line 417 of file cuddApa.c.

 {
     int i;
     int index;
 
     for (i = 0; i < digits; i++)
         number[i] = 0;
     i = digits - 1 - power / DD_APA_BITS;
     if (i < 0) return;
     index = power & (DD_APA_BITS - 1);
     number[i] = 1 << index;
 
 } /* end of Cudd_ApaPowerOfTwo */

int Cudd_ApaPrintDecimal	(	FILE *	fp,
		int	digits,
		DdApaNumber	number
	)

Function********************************************************************

Synopsis [Prints an arbitrary precision integer in decimal format.]

Description [Prints an arbitrary precision integer in decimal format. Returns 1 if successful; 0 otherwise.]

SideEffects [None]

SeeAlso [Cudd_ApaPrintHex Cudd_ApaPrintExponential]

Definition at line 562 of file cuddApa.c.

 {
     int i, result;
     DdApaDigit remainder;
     DdApaNumber work;
     unsigned char *decimal;
     int leadingzero;
     int decimalDigits = (int) (digits * log10((double) DD_APA_BASE)) + 1;
 
     work = Cudd_NewApaNumber(digits);
     if (work == NULL)
         return(0);
     decimal = ABC_ALLOC(unsigned char, decimalDigits);
     if (decimal == NULL) {
         ABC_FREE(work);
         return(0);
     }
     Cudd_ApaCopy(digits,number,work);
     for (i = decimalDigits - 1; i >= 0; i--) {
         remainder = Cudd_ApaShortDivision(digits,work,(DdApaDigit) 10,work);
         decimal[i] = (unsigned char) remainder;
     }
     ABC_FREE(work);
 
     leadingzero = 1;
     for (i = 0; i < decimalDigits; i++) {
         leadingzero = leadingzero && (decimal[i] == 0);
         if ((!leadingzero) || (i == (decimalDigits - 1))) {
             result = fprintf(fp,"%1d",decimal[i]);
             if (result == EOF) {
                 ABC_FREE(decimal);
                 return(0);
             }
         }
     }
     ABC_FREE(decimal);
     return(1);
 
 } /* end of Cudd_ApaPrintDecimal */

int Cudd_ApaPrintDensity	(	FILE *	fp,
		DdManager *	dd,
		DdNode *	node,
		int	nvars
	)

Function********************************************************************

Synopsis [Prints the density of a BDD or ADD using arbitrary precision arithmetic.]

Description [Prints the density of a BDD or ADD using arbitrary precision arithmetic. Returns 1 if successful; 0 otherwise.]

SideEffects [None]

SeeAlso []

Definition at line 838 of file cuddApa.c.

 {
     int digits;
     int result;
     DdApaNumber count,density;
     unsigned int size, remainder, fractional;
 
     count = Cudd_ApaCountMinterm(dd,node,nvars,&digits);
     if (count == NULL)
         return(0);
     size = Cudd_DagSize(node);
     density = Cudd_NewApaNumber(digits);
     remainder = Cudd_ApaIntDivision(digits,count,size,density);
     result = Cudd_ApaPrintDecimal(fp,digits,density);
     ABC_FREE(count);
     ABC_FREE(density);
     fractional = (unsigned int)((double)remainder / size * 1000000);
     if (fprintf(fp,".%u\n", fractional) == EOF) {
         return(0);
     }
     return(result);
 
 } /* end of Cudd_ApaPrintDensity */

int Cudd_ApaPrintExponential	(	FILE *	fp,
		int	digits,
		DdApaNumber	number,
		int	precision
	)

Function********************************************************************

Synopsis [Prints an arbitrary precision integer in exponential format.]

Description [Prints an arbitrary precision integer in exponential format. Returns 1 if successful; 0 otherwise.]

SideEffects [None]

SeeAlso [Cudd_ApaPrintHex Cudd_ApaPrintDecimal]

Definition at line 619 of file cuddApa.c.

 {
     int i, first, last, result;
     DdApaDigit remainder;
     DdApaNumber work;
     unsigned char *decimal;
     int decimalDigits = (int) (digits * log10((double) DD_APA_BASE)) + 1;
 
     work = Cudd_NewApaNumber(digits);
     if (work == NULL)
         return(0);
     decimal = ABC_ALLOC(unsigned char, decimalDigits);
     if (decimal == NULL) {
         ABC_FREE(work);
         return(0);
     }
     Cudd_ApaCopy(digits,number,work);
     first = decimalDigits - 1;
     for (i = decimalDigits - 1; i >= 0; i--) {
         remainder = Cudd_ApaShortDivision(digits,work,(DdApaDigit) 10,work);
         decimal[i] = (unsigned char) remainder;
         if (remainder != 0) first = i; /* keep track of MS non-zero */
     }
     ABC_FREE(work);
     last = ddMin(first + precision, decimalDigits);
 
     for (i = first; i < last; i++) {
         result = fprintf(fp,"%s%1d",i == first+1 ? "." : "", decimal[i]);
         if (result == EOF) {
             ABC_FREE(decimal);
             return(0);
         }
     }
     ABC_FREE(decimal);
     result = fprintf(fp,"e+%d",decimalDigits - first - 1);
     if (result == EOF) {
         return(0);
     }
     return(1);
 
 } /* end of Cudd_ApaPrintExponential */

int Cudd_ApaPrintHex	(	FILE *	fp,
		int	digits,
		DdApaNumber	number
	)

Function********************************************************************

Synopsis [Prints an arbitrary precision integer in hexadecimal format.]

Description [Prints an arbitrary precision integer in hexadecimal format. Returns 1 if successful; 0 otherwise.]

SideEffects [None]

SeeAlso [Cudd_ApaPrintDecimal Cudd_ApaPrintExponential]

Definition at line 532 of file cuddApa.c.

 {
     int i, result;
 
     for (i = 0; i < digits; i++) {
         result = fprintf(fp,DD_APA_HEXPRINT,number[i]);
         if (result == EOF)
             return(0);
     }
     return(1);
 
 } /* end of Cudd_ApaPrintHex */

int Cudd_ApaPrintMinterm	(	FILE *	fp,
		DdManager *	dd,
		DdNode *	node,
		int	nvars
	)

Function********************************************************************

Synopsis [Prints the number of minterms of a BDD or ADD using arbitrary precision arithmetic.]

Description [Prints the number of minterms of a BDD or ADD using arbitrary precision arithmetic. Returns 1 if successful; 0 otherwise.]

SideEffects [None]

SeeAlso [Cudd_ApaPrintMintermExp]

Definition at line 761 of file cuddApa.c.

 {
     int digits;
     int result;
     DdApaNumber count;
 
     count = Cudd_ApaCountMinterm(dd,node,nvars,&digits);
     if (count == NULL)
         return(0);
     result = Cudd_ApaPrintDecimal(fp,digits,count);
     ABC_FREE(count);
     if (fprintf(fp,"\n") == EOF) {
         return(0);
     }
     return(result);
 
 } /* end of Cudd_ApaPrintMinterm */

int Cudd_ApaPrintMintermExp	(	FILE *	fp,
		DdManager *	dd,
		DdNode *	node,
		int	nvars,
		int	precision
	)

Function********************************************************************

Synopsis [Prints the number of minterms of a BDD or ADD in exponential format using arbitrary precision arithmetic.]

Description [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.]

SideEffects [None]

SeeAlso [Cudd_ApaPrintMinterm]

Definition at line 800 of file cuddApa.c.

 {
     int digits;
     int result;
     DdApaNumber count;
 
     count = Cudd_ApaCountMinterm(dd,node,nvars,&digits);
     if (count == NULL)
         return(0);
     result = Cudd_ApaPrintExponential(fp,digits,count,precision);
     ABC_FREE(count);
     if (fprintf(fp,"\n") == EOF) {
         return(0);
     }
     return(result);
 
 } /* end of Cudd_ApaPrintMintermExp */

void Cudd_ApaSetToLiteral	(	int	digits,
		DdApaNumber	number,
		DdApaDigit	literal
	)

Function********************************************************************

Synopsis [Sets an arbitrary precision integer to a one-digit literal.]

Description [Sets an arbitrary precision integer to a one-digit literal.]

SideEffects [The result is returned in parameter number.]

SeeAlso []

Definition at line 389 of file cuddApa.c.

 {
     int i;
 
     for (i = 0; i < digits - 1; i++)
         number[i] = 0;
     number[digits - 1] = literal;
 
 } /* end of Cudd_ApaSetToLiteral */

void Cudd_ApaShiftRight	(	int	digits,
		DdApaDigit	in,
		DdApaNumber	a,
		DdApaNumber	b
	)

Function********************************************************************

Synopsis [Shifts right an arbitrary precision integer by one binary place.]

Description [Shifts right an arbitrary precision integer by one binary place. The most significant binary digit of the result is taken from parameter in.]

SideEffects [The result is returned in parameter b.]

SeeAlso []

Definition at line 361 of file cuddApa.c.

 {
     int i;
 
     for (i = digits - 1; i > 0; i--) {
         b[i] = (a[i] >> 1) | ((a[i-1] & 1) << (DD_APA_BITS - 1));
     }
     b[0] = (a[0] >> 1) | (in << (DD_APA_BITS - 1));
 
 } /* end of Cudd_ApaShiftRight */

DdApaDigit Cudd_ApaShortDivision	(	int	digits,
		DdApaNumber	dividend,
		DdApaDigit	divisor,
		DdApaNumber	quotient
	)

Function********************************************************************

Synopsis [Divides an arbitrary precision integer by a digit.]

Description [Divides an arbitrary precision integer by a digit.]

SideEffects [The quotient is returned in parameter quotient.]

SeeAlso []

Definition at line 283 of file cuddApa.c.

 {
     int i;
     DdApaDigit remainder;
     DdApaDoubleDigit partial;
 
     remainder = 0;
     for (i = 0; i < digits; i++) {
         partial = remainder * DD_APA_BASE + dividend[i];
         quotient[i] = (DdApaDigit) (partial/(DdApaDoubleDigit)divisor);
         remainder = (DdApaDigit) (partial % divisor);
     }
 
     return(remainder);
 
 } /* end of Cudd_ApaShortDivision */

DdApaDigit Cudd_ApaSubtract	(	int	digits,
		DdApaNumber	a,
		DdApaNumber	b,
		DdApaNumber	diff
	)

Function********************************************************************

Synopsis [Subtracts two arbitrary precision integers.]

Description [Subtracts two arbitrary precision integers. Returns the borrow out of the most significant digit.]

SideEffects [The result of the subtraction is stored in parameter diff.]

SeeAlso []

Definition at line 253 of file cuddApa.c.

 {
     int i;
     DdApaDoubleDigit partial = DD_APA_BASE;
 
     for (i = digits - 1; i >= 0; i--) {
         partial = DD_MSDIGIT(partial) + DD_APA_MASK + a[i] - b[i];
         diff[i] = (DdApaDigit) DD_LSDIGIT(partial);
     }
     return((DdApaDigit) DD_MSDIGIT(partial) - 1);
 
 } /* end of Cudd_ApaSubtract */

DdApaNumber Cudd_NewApaNumber ( int digits )

Function********************************************************************

Synopsis [Allocates memory for an arbitrary precision integer.]

Description [Allocates memory for an arbitrary precision integer. Returns a pointer to the allocated memory if successful; NULL otherwise.]

SideEffects [None]

SeeAlso []

Definition at line 174 of file cuddApa.c.

 {
     return(ABC_ALLOC(DdApaDigit, digits));
 
 } /* end of Cudd_NewApaNumber */

static DdApaNumber cuddApaCountMintermAux	(	DdNode *	node,
		int	digits,
		DdApaNumber	max,
		DdApaNumber	min,
		st__table *	table
	)

static

AutomaticStart

Function********************************************************************

Synopsis [Performs the recursive step of Cudd_ApaCountMinterm.]

Description [Performs the recursive step of Cudd_ApaCountMinterm. It is based on the following identity. Let |f| be the number of minterms of f. Then: <xmp> |f| = (|f0|+|f1|)/2 </xmp> where f0 and f1 are the two cofactors of f. Uses the identity |f'| = max - |f|. The procedure expects the argument "node" to be a regular pointer, and guarantees this condition is met in the recursive calls. For efficiency, the result of a call is cached only if the node has a reference count greater than 1. Returns the number of minterms of the function rooted at node.]

SideEffects [None]

Definition at line 899 of file cuddApa.c.

 {
     DdNode      *Nt, *Ne;
     DdApaNumber mint, mint1, mint2;
     DdApaDigit  carryout;
 
     if (cuddIsConstant(node)) {
         if (node == background || node == zero) {
             return(min);
         } else {
             return(max);
         }
     }
     if (node->ref > 1 && st__lookup(table, (const char *)node, (char **)&mint)) {
         return(mint);
     }
 
     Nt = cuddT(node); Ne = cuddE(node);
 
     mint1 = cuddApaCountMintermAux(Nt,  digits, max, min, table);
     if (mint1 == NULL) return(NULL);
     mint2 = cuddApaCountMintermAux(Cudd_Regular(Ne), digits, max, min, table);
     if (mint2 == NULL) {
         if (Nt->ref == 1) ABC_FREE(mint1);
         return(NULL);
     }
     mint = Cudd_NewApaNumber(digits);
     if (mint == NULL) {
         if (Nt->ref == 1) ABC_FREE(mint1);
         if (Cudd_Regular(Ne)->ref == 1) ABC_FREE(mint2);
         return(NULL);
     }
     if (Cudd_IsComplement(Ne)) {
         (void) Cudd_ApaSubtract(digits,max,mint2,mint);
         carryout = Cudd_ApaAdd(digits,mint1,mint,mint);
     } else {
         carryout = Cudd_ApaAdd(digits,mint1,mint2,mint);
     }
     Cudd_ApaShiftRight(digits,carryout,mint,mint);
     /* If the refernce count of a child is 1, its minterm count
     ** hasn't been stored in table.  Therefore, it must be explicitly
     ** freed here. */
     if (Nt->ref == 1) ABC_FREE(mint1);
     if (Cudd_Regular(Ne)->ref == 1) ABC_FREE(mint2);
 
     if (node->ref > 1) {
         if ( st__insert(table, (char *)node, (char *)mint) == st__OUT_OF_MEM) {
             ABC_FREE(mint);
             return(NULL);
         }
     }
     return(mint);
 
 } /* end of cuddApaCountMintermAux */

static enum st__retval cuddApaStCountfree	(	char *	key,
		char *	value,
		char *	arg
	)

static

Function********************************************************************

Synopsis [Frees the memory used to store the minterm counts recorded in the visited table.]

Description [Frees the memory used to store the minterm counts recorded in the visited table. Returns st__CONTINUE.]

SideEffects [None]

Definition at line 972 of file cuddApa.c.

 {
     DdApaNumber d;
 
     d = (DdApaNumber) value;
     ABC_FREE(d);
     return( st__CONTINUE);
 
 } /* end of cuddApaStCountfree */

Variable Documentation

DdNode* background

static

Definition at line 100 of file cuddApa.c.

ABC_NAMESPACE_IMPL_START char rcsid [] DD_UNUSED = "$Id: cuddApa.c,v 1.19 2009/03/08 01:27:50 fabio Exp $"

static

CFile***********************************************************************

FileName [cuddApa.c]

PackageName [cudd]

Synopsis [Arbitrary precision arithmetic functions.]

Description [External procedures included in this module:

Static procedures included in this module:

]

Author [Fabio Somenzi]

Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:

Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.

Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.

Neither the name of the University of Colorado nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.]

Definition at line 97 of file cuddApa.c.

DdNode * zero

static

Definition at line 100 of file cuddApa.c.

Functions

Variables

Function Documentation

Variable Documentation