setc.c File Reference

#include "espresso.h"

Go to the source code of this file.

Functions
ABC_NAMESPACE_IMPL_START bool	full_row (IN register pcube p, IN register pcube cof)
bool	cdist0 (pcube a, pcube b)
int	cdist01 (pset a, pset b)
int	cdist (pset a, pset b)
pset	force_lower (INOUT pset xlower, IN register pset a, IN register pset b)
void	consensus (INOUT pcube r, IN register pcube a, IN register pcube b)
int	cactive (pcube a)
bool	ccommon (pcube a, pcube b, pcube cof)
int	descend (pset *a, pset *b)
int	ascend (pset *a, pset *b)
int	lex_order (pset *a, pset *b)
int	d1_order (pset *a, pset *b)
int	desc1 (pset a, pset b)

Function Documentation

int ascend	(	pset *	a,
		pset *	b
	)

Definition at line 423 of file setc.c.

{
    register pset a1 = *a, b1 = *b;
    if (SIZE(a1) > SIZE(b1)) return 1;
    else if (SIZE(a1) < SIZE(b1)) return -1;
    else {
    register int i = LOOP(a1);
    do
        if (a1[i] > b1[i]) return 1; else if (a1[i] < b1[i]) return -1;
    while (--i > 0);
    }
    return 0;
}

int cactive

(

pcube

a

)

Definition at line 293 of file setc.c.

{
    int active = -1, dist = 0, bit_index();

 {  /* Check binary variables */
    register int w, last;
    register unsigned int x;
    if ((last = cube.inword) != -1) {

    /* Check the partial word of binary variables */
    x = a[last];
    if ((x = ~ (x & x >> 1) & cube.inmask)) {
        if ((dist = count_ones(x)) > 1)
        return -1;      /* more than 2 active variables */
        active = (last-1)*(BPI/2) + bit_index(x) / 2;
    }

    /* Check the full words of binary variables */
    for(w = 1; w < last; w++) {
        x = a[w];
        if ((x = ~ (x & x >> 1) & DISJOINT)) {
        if ((dist += count_ones(x)) > 1)
            return -1;      /* more than 2 active variables */
        active = (w-1)*(BPI/2) + bit_index(x) / 2;
        }
    }
    }
 }

 {  /* Check the multiple-valued variables */
    register int w, var, last;
    register pcube mask;
    for(var = cube.num_binary_vars; var < cube.num_vars; var++) {
    mask = cube.var_mask[var];
    last = cube.last_word[var];
    for(w = cube.first_word[var]; w <= last; w++)
        if (mask[w] & ~ a[w]) {
        if (++dist > 1)
            return -1;
        active = var;
        break;
        }
    }
 }
 return active;
}

bool ccommon	(	pcube	a,
		pcube	b,
		pcube	cof
	)

Definition at line 346 of file setc.c.

{
 {  /* Check binary variables */
    int last;
    register int w;
    register unsigned int x, y;
    if ((last = cube.inword) != -1) {

    /* Check the partial word of binary variables */
    x = a[last] | cof[last];
    y = b[last] | cof[last];
    if (~(x & x>>1) & ~(y & y>>1) & cube.inmask)
        return TRUE;

    /* Check the full words of binary variables */
    for(w = 1; w < last; w++) {
        x = a[w] | cof[w];
        y = b[w] | cof[w];
        if (~(x & x>>1) & ~(y & y>>1) & DISJOINT)
        return TRUE;
    }
    }
 }

 {  /* Check the multiple-valued variables */
    int var;
    register int w, last;
    register pcube mask;
    for(var = cube.num_binary_vars; var < cube.num_vars; var++) {
    mask = cube.var_mask[var]; last = cube.last_word[var];
    /* Check for some part missing from a */
    for(w = cube.first_word[var]; w <= last; w++)
        if (mask[w] & ~a[w] & ~cof[w]) {

        /* If so, check for some part missing from b */
        for(w = cube.first_word[var]; w <= last; w++)
            if (mask[w] & ~b[w] & ~cof[w])
            return TRUE;            /* both active */
        break;
        }
    }
 }
    return FALSE;
}

int cdist	(	pset	a,
		pset	b
	)

Definition at line 154 of file setc.c.

{
    int dist = 0;

 {  /* Check binary variables */
    register int w, last; register unsigned int x;
    if ((last = cube.inword) != -1) {

    /* Check the partial word of binary variables */
    x = a[last] & b[last];
    if ((x = ~ (x | x >> 1) & cube.inmask))
        dist = count_ones(x);

    /* Check the full words of binary variables */
    for(w = 1; w < last; w++) {
        x = a[w] & b[w];
        if ((x = ~ (x | x >> 1) & DISJOINT))
        dist += count_ones(x);
    }
    }
 }

 {  /* Check the multiple-valued variables */
    register int w, var, last; register pcube mask;
    for(var = cube.num_binary_vars; var < cube.num_vars; var++) {
    mask = cube.var_mask[var]; last = cube.last_word[var];
    for(w = cube.first_word[var]; w <= last; w++)
        if (a[w] & b[w] & mask[w])
        goto nextvar;
    dist++;
    nextvar: ;
    }
 }
    return dist;
}

bool cdist0	(	pcube	a,
		pcube	b
	)

Definition at line 68 of file setc.c.

{
 {  /* Check binary variables */
    register int w, last; register unsigned int x;
    if ((last = cube.inword) != -1) {

    /* Check the partial word of binary variables */
    x = a[last] & b[last];
    if (~(x | x >> 1) & cube.inmask)
        return FALSE;               /* disjoint in some variable */

    /* Check the full words of binary variables */
    for(w = 1; w < last; w++) {
        x = a[w] & b[w];
        if (~(x | x >> 1) & DISJOINT)
        return FALSE;           /* disjoint in some variable */
    }
    }
 }

 {  /* Check the multiple-valued variables */
    register int w, var, last; register pcube mask;
    for(var = cube.num_binary_vars; var < cube.num_vars; var++) {
    mask = cube.var_mask[var]; last = cube.last_word[var];
    for(w = cube.first_word[var]; w <= last; w++)
        if (a[w] & b[w] & mask[w])
        goto nextvar;
    return FALSE;           /* disjoint in this variable */
    nextvar: ;
    }
 }
    return TRUE;
}

int cdist01	(	pset	a,
		pset	b
	)

Definition at line 109 of file setc.c.

{
    int dist = 0;

 {  /* Check binary variables */
    register int w, last; register unsigned int x;
    if ((last = cube.inword) != -1) {

    /* Check the partial word of binary variables */
    x = a[last] & b[last];
    if ((x = ~ (x | x >> 1) & cube.inmask))
        if ((dist = count_ones(x)) > 1)
        return 2;

    /* Check the full words of binary variables */
    for(w = 1; w < last; w++) {
        x = a[w] & b[w];
        if ((x = ~ (x | x >> 1) & DISJOINT))
        if (dist == 1 || (dist += count_ones(x)) > 1)
            return 2;
    }
    }
 }

 {  /* Check the multiple-valued variables */
    register int w, var, last; register pcube mask;
    for(var = cube.num_binary_vars; var < cube.num_vars; var++) {
    mask = cube.var_mask[var]; last = cube.last_word[var];
    for(w = cube.first_word[var]; w <= last; w++)
        if (a[w] & b[w] & mask[w])
        goto nextvar;
    if (++dist > 1)
        return 2;
    nextvar: ;
    }
 }
    return dist;
}

void consensus	(	INOUT pcube	r,
		IN register pcube	a,
		IN register pcube	b
	)

Definition at line 246 of file setc.c.

{
    INLINEset_clear(r, cube.size);

 {  /* Check binary variables (if any) */
    register int w, last; register unsigned int x;
    if ((last = cube.inword) != -1) {

    /* Check the partial word of binary variables */
    r[last] = x = a[last] & b[last];
    if ((x = ~(x | x >> 1) & cube.inmask))
        r[last] |= (x | (x << 1)) & (a[last] | b[last]);

    /* Check the full words of binary variables */
    for(w = 1; w < last; w++) {
        r[w] = x = a[w] & b[w];
        if ((x = ~(x | x >> 1) & DISJOINT))
        r[w] |= (x | (x << 1)) & (a[w] | b[w]);
    }
    }
 }


 {  /* Check the multiple-valued variables */
    bool empty; int var; unsigned int x;
    register int w, last; register pcube mask;
    for(var = cube.num_binary_vars; var < cube.num_vars; var++) {
    mask = cube.var_mask[var];
    last = cube.last_word[var];
    empty = TRUE;
    for(w = cube.first_word[var]; w <= last; w++)
        if ((x = a[w] & b[w] & mask[w]))
        empty = FALSE, r[w] |= x;
    if (empty)
        for(w = cube.first_word[var]; w <= last; w++)
        r[w] |= mask[w] & (a[w] | b[w]);
    }
 }
}

int d1_order	(	pset *	a,
		pset *	b
	)

Definition at line 453 of file setc.c.

{
    register pset a1 = *a, b1 = *b, c1 = cube.temp[0];
    register int i = LOOP(a1);
    register unsigned int x1, x2;
    do
    if ((x1 = a1[i] | c1[i]) > (x2 = b1[i] | c1[i])) return -1;
    else if (x1 < x2) return 1;
    while (--i > 0);
    return 0;
}

int desc1	(	pset	a,
		pset	b
	)

Definition at line 470 of file setc.c.

{
    if (a == (pset) NULL)
    return (b == (pset) NULL) ? 0 : 1;
    else if (b == (pset) NULL)
    return -1;
    if (SIZE(a) > SIZE(b)) return -1;
    else if (SIZE(a) < SIZE(b)) return 1;
    else {
    register int i = LOOP(a);
    do
        if (a[i] > b[i]) return -1; else if (a[i] < b[i]) return 1;
    while (--i > 0);
    }
    return 0;
}

int descend	(	pset *	a,
		pset *	b
	)

Definition at line 407 of file setc.c.

{
    register pset a1 = *a, b1 = *b;
    if (SIZE(a1) > SIZE(b1)) return -1;
    else if (SIZE(a1) < SIZE(b1)) return 1;
    else {
    register int i = LOOP(a1);
    do
        if (a1[i] > b1[i]) return -1; else if (a1[i] < b1[i]) return 1;
    while (--i > 0);
    }
    return 0;
}

pset force_lower	(	INOUT pset	xlower,
		IN register pset	a,
		IN register pset	b
	)

Definition at line 195 of file setc.c.

{

 {  /* Check binary variables (if any) */
    register int w, last; register unsigned int x;
    if ((last = cube.inword) != -1) {

    /* Check the partial word of binary variables */
    x = a[last] & b[last];
    if ((x = ~(x | x >> 1) & cube.inmask))
        xlower[last] |= (x | (x << 1)) & a[last];

    /* Check the full words of binary variables */
    for(w = 1; w < last; w++) {
        x = a[w] & b[w];
        if ((x = ~(x | x >> 1) & DISJOINT))
        xlower[w] |= (x | (x << 1)) & a[w];
    }
    }
 }

 {  /* Check the multiple-valued variables */
    register int w, var, last; register pcube mask;
    for(var = cube.num_binary_vars; var < cube.num_vars; var++) {
    mask = cube.var_mask[var]; last = cube.last_word[var];
    for(w = cube.first_word[var]; w <= last; w++)
        if (a[w] & b[w] & mask[w])
        goto nextvar;
    for(w = cube.first_word[var]; w <= last; w++)
        xlower[w] |= a[w] & mask[w];
    nextvar: ;
    }
 }
    return xlower;
}

ABC_NAMESPACE_IMPL_START bool full_row	(	IN register pcube	p,
		IN register pcube	cof
	)

Definition at line 56 of file setc.c.

{
    register int i = LOOP(p);
    do if ((p[i] | cof[i]) != cube.fullset[i]) return FALSE; while (--i > 0);
    return TRUE;
}

int lex_order	(	pset *	a,
		pset *	b
	)

Definition at line 440 of file setc.c.

{
    register pset a1 = *a, b1 = *b;
    register int i = LOOP(a1);
    do
    if (a1[i] > b1[i]) return -1; else if (a1[i] < b1[i]) return 1;
    while (--i > 0);
    return 0;
}