essen.c File Reference

#include "espresso.h"

Include dependency graph for essen.c:

Go to the source code of this file.

Functions
ABC_NAMESPACE_IMPL_START pcover	essential (IN pcover *Fp, IN pcover *Dp)
bool	essen_cube (IN pcover F, IN pcover D, IN pcube c)
pcover	cb_consensus (pcover T, pcube c)
pcover	cb_consensus_dist0 (pcover R, pcube p, pcube c)

Function Documentation

cb_consensus()

pcover cb_consensus	(	pcover	T,
		pcube	c )

Definition at line 109 of file essen.c.

{
    register pcube temp, last, p;
    register pcover R;
 
    R = new_cover(T->count*2);
    temp = new_cube();
    foreach_set(T, last, p) {
    if (p != c) {
        switch (cdist01(p, c)) {
        case 0:
            /* distance-0 needs special care */
            R = cb_consensus_dist0(R, p, c);
            break;
 
        case 1:
            /* distance-1 is easy because no sharping required */
            consensus(temp, p, c);
            R = sf_addset(R, temp);
            break;
        }
    }
    }
    set_free(temp);
    return R;
}

Here is the call graph for this function:

cb_consensus_dist0()

pcover cb_consensus_dist0	(	pcover	R,
		pcube	p,
		pcube	c )

Definition at line 143 of file essen.c.

{
    int var;
    bool got_one;
    register pcube temp, mask;
    register pcube p_diff_c=cube.temp[0], p_and_c=cube.temp[1];
 
    /* If c contains p, then this gives us no information for essential test */
    if (setp_implies(p, c)) {
    return R;
    }
 
    /* For the multiple-valued variables */
    temp = new_cube();
    got_one = FALSE;
    INLINEset_diff(p_diff_c, p, c);
    INLINEset_and(p_and_c, p, c);
 
    for(var = cube.num_binary_vars; var < cube.num_vars; var++) {
    /* Check if c(var) is contained in p(var) -- if so, no news */
    mask = cube.var_mask[var];
    if (! setp_disjoint(p_diff_c, mask)) {
        INLINEset_merge(temp, c, p_and_c, mask);
        R = sf_addset(R, temp);
        got_one = TRUE;
    }
    }
 
    /* if no cube so far, add one for the intersection */
    if (! got_one && cube.num_binary_vars > 0) {
    /* Add a single cube for the intersection of p and c */
    INLINEset_and(temp, p, c);
    R = sf_addset(R, temp);
    }
 
    set_free(temp);
    return R;
}

Here is the call graph for this function:

essen_cube()

bool essen_cube	(	IN pcover	F,
		IN pcover	D,
		IN pcube	c )

Definition at line 83 of file essen.c.

{
    pcover H, FD;
    pcube *H1;
    bool essen;
 
    /* Append F and D together, and take the sharp-consensus with c */
    FD = sf_join(F, D);
    H = cb_consensus(FD, c);
    free_cover(FD);
 
    /* Add the don't care set, and see if this covers c */
    H1 = cube2list(H, D);
    essen = ! cube_is_covered(H1, c);
    free_cubelist(H1);
 
    free_cover(H);
    return essen;
}

Here is the call graph for this function:

essential()

ABC_NAMESPACE_IMPL_START pcover essential	(	IN pcover *	Fp,
		IN pcover *	Dp )

Definition at line 39 of file essen.c.

{
    register pcube last, p;
    pcover E, F = *Fp, D = *Dp;
 
    /* set all cubes in F active */
    (void) sf_active(F);
 
    /* Might as well start out with some cubes in E */
    E = new_cover(10);
 
    foreach_set(F, last, p) {
    /* don't test a prime which EXPAND says is nonessential */
    if (! TESTP(p, NONESSEN)) {
        /* only test a prime which was relatively essential */
        if (TESTP(p, RELESSEN)) {
        /* Check essentiality */
        if (essen_cube(F, D, p)) {
            if (debug & ESSEN)
            printf("ESSENTIAL: %s\n", pc1(p));
            E = sf_addset(E, p);
            RESET(p, ACTIVE);
            F->active_count--;
        }
        }
    }
    }
 
    *Fp = sf_inactive(F);               /* delete the inactive cubes from F */
    *Dp = sf_join(D, E);        /* add the essentials to D */
    sf_free(D);
    return E;
}

Here is the call graph for this function: