src/misc/espresso/essen.c File Reference

#include "espresso.h"

Include dependency graph for essen.c:

Go to the source code of this file.

Functions
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

pcover cb_consensus	(	pcover	T,
		pcube	c
	)

Definition at line 106 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;
}

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

Definition at line 140 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;
}

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

Definition at line 80 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;
}

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

Definition at line 36 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;
}