Data Structures
struct	Dec_Edge_t_

struct	Dec_Node_t_

struct	Dec_Graph_t_

struct	Dec_Man_t_

Macros
#define	Dec_GraphForEachLeaf(pGraph, pLeaf, i) for ( i = 0; (i < (pGraph)->nLeaves) && (((pLeaf) = Dec_GraphNode(pGraph, i)), 1); i++ )
	ITERATORS ///. More...

#define	Dec_GraphForEachNode(pGraph, pAnd, i) for ( i = (pGraph)->nLeaves; (i < (pGraph)->nSize) && (((pAnd) = Dec_GraphNode(pGraph, i)), 1); i++ )

Typedefs
typedef typedefABC_NAMESPACE_HEADER_START struct Dec_Edge_t_	Dec_Edge_t
	INCLUDES ///. More...

typedef struct Dec_Node_t_	Dec_Node_t

typedef struct Dec_Graph_t_	Dec_Graph_t

typedef struct Dec_Man_t_	Dec_Man_t

Functions
Dec_Graph_t *	Dec_Factor (char *pSop)
	FUNCTION DECLARATIONS ///. More...

Dec_Man_t *	Dec_ManStart ()
	DECLARATIONS ///. More...

void	Dec_ManStop (Dec_Man_t *p)

void	Dec_GraphPrint (FILE pFile, Dec_Graph_t pGraph, char pNamesIn[], char pNameOut)
	FUNCTION DEFINITIONS ///. More...

unsigned	Dec_GraphDeriveTruth (Dec_Graph_t *pGraph)

static Dec_Edge_t	Dec_EdgeCreate (int Node, int fCompl)
	FUNCTION DEFINITIONS ///. More...

static unsigned	Dec_EdgeToInt (Dec_Edge_t eEdge)

static Dec_Edge_t	Dec_IntToEdge (unsigned Edge)

static unsigned	Dec_EdgeToInt_ (Dec_Edge_t m)

static Dec_Edge_t	Dec_IntToEdge_ (unsigned m)

static Dec_Graph_t *	Dec_GraphCreate (int nLeaves)

static Dec_Graph_t *	Dec_GraphCreateConst0 ()

static Dec_Graph_t *	Dec_GraphCreateConst1 ()

static Dec_Graph_t *	Dec_GraphCreateLeaf (int iLeaf, int nLeaves, int fCompl)

static void	Dec_GraphFree (Dec_Graph_t *pGraph)

static int	Dec_GraphIsConst (Dec_Graph_t *pGraph)

static int	Dec_GraphIsConst0 (Dec_Graph_t *pGraph)

static int	Dec_GraphIsConst1 (Dec_Graph_t *pGraph)

static int	Dec_GraphIsComplement (Dec_Graph_t *pGraph)

static void	Dec_GraphComplement (Dec_Graph_t *pGraph)

static int	Dec_GraphLeaveNum (Dec_Graph_t *pGraph)

static int	Dec_GraphNodeNum (Dec_Graph_t *pGraph)

static Dec_Node_t *	Dec_GraphNode (Dec_Graph_t *pGraph, int i)

static Dec_Node_t *	Dec_GraphNodeLast (Dec_Graph_t *pGraph)

static int	Dec_GraphNodeInt (Dec_Graph_t pGraph, Dec_Node_t pNode)

static int	Dec_GraphIsVar (Dec_Graph_t *pGraph)

static int	Dec_GraphNodeIsVar (Dec_Graph_t pGraph, Dec_Node_t pNode)

static Dec_Node_t *	Dec_GraphVar (Dec_Graph_t *pGraph)

static int	Dec_GraphVarInt (Dec_Graph_t *pGraph)

static void	Dec_GraphSetRoot (Dec_Graph_t *pGraph, Dec_Edge_t eRoot)

static Dec_Node_t *	Dec_GraphAppendNode (Dec_Graph_t *pGraph)

static Dec_Edge_t	Dec_GraphAddNodeAnd (Dec_Graph_t *pGraph, Dec_Edge_t eEdge0, Dec_Edge_t eEdge1)

static Dec_Edge_t	Dec_GraphAddNodeOr (Dec_Graph_t *pGraph, Dec_Edge_t eEdge0, Dec_Edge_t eEdge1)

static Dec_Edge_t	Dec_GraphAddNodeXor (Dec_Graph_t *pGraph, Dec_Edge_t eEdge0, Dec_Edge_t eEdge1, int Type)

static Dec_Edge_t	Dec_GraphAddNodeMux (Dec_Graph_t *pGraph, Dec_Edge_t eEdgeC, Dec_Edge_t eEdgeT, Dec_Edge_t eEdgeE, int Type)

Macro Definition Documentation

#define Dec_GraphForEachLeaf	(	pGraph,
		pLeaf,
		i
	)	for ( i = 0; (i < (pGraph)->nLeaves) && (((pLeaf) = Dec_GraphNode(pGraph, i)), 1); i++ )

ITERATORS ///.

Definition at line 98 of file dec.h.

#define Dec_GraphForEachNode	(	pGraph,
		pAnd,
		i
	)	for ( i = (pGraph)->nLeaves; (i < (pGraph)->nSize) && (((pAnd) = Dec_GraphNode(pGraph, i)), 1); i++ )

Definition at line 101 of file dec.h.

Typedef Documentation

typedef typedefABC_NAMESPACE_HEADER_START struct Dec_Edge_t_ Dec_Edge_t

INCLUDES ///.

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

FileName [dec.h]

SystemName [ABC: Logic synthesis and verification system.]

PackageName [A simple decomposition tree/node data structure and its APIs.]

Synopsis [External declarations.]

Author [Alan Mishchenko]

Affiliation [UC Berkeley]

Date [Ver. 1.0. Started - June 20, 2005.]

Revision [

Id:: dec.h,v 1.00 2005/06/20 00:00:00 alanmi Exp

]PARAMETERS ///BASIC TYPES ///

Definition at line 42 of file dec.h.

typedef struct Dec_Graph_t_ Dec_Graph_t

Definition at line 68 of file dec.h.

typedef struct Dec_Man_t_ Dec_Man_t

Definition at line 79 of file dec.h.

typedef struct Dec_Node_t_ Dec_Node_t

Definition at line 49 of file dec.h.

Function Documentation

static Dec_Edge_t Dec_EdgeCreate	(	int	Node,
		int	fCompl
	)

inlinestatic

FUNCTION DEFINITIONS ///.

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

Synopsis [Creates an edge pointing to the node in the given polarity.]

Description []

SideEffects []

SeeAlso []

Definition at line 134 of file dec.h.

 {
     Dec_Edge_t eEdge = { fCompl, Node }; 
     return eEdge; 
 }

static unsigned Dec_EdgeToInt ( Dec_Edge_t eEdge )

inlinestatic

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

Synopsis [Converts the edge into unsigned integer.]

Description []

SideEffects []

SeeAlso []

Definition at line 151 of file dec.h.

 {
     return (eEdge.Node << 1) | eEdge.fCompl; 
 }

static unsigned Dec_EdgeToInt_ ( Dec_Edge_t m )

inlinestatic

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

Synopsis [Converts the edge into unsigned integer.]

Description []

SideEffects []

SeeAlso []

Definition at line 183 of file dec.h.

183 { union { Dec_Edge_t x; unsigned y; } v; v.x = m; return v.y; }

Dec_Edge_t

typedefABC_NAMESPACE_HEADER_START struct Dec_Edge_t_ Dec_Edge_t

INCLUDES ///.

Definition: dec.h:42

Dec_Graph_t* Dec_Factor ( char * pSop )

FUNCTION DECLARATIONS ///.

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

Synopsis [Factors the cover.]

Description []

SideEffects []

SeeAlso []

Definition at line 55 of file decFactor.c.

 {
     Mvc_Cover_t * pCover;
     Dec_Graph_t * pFForm;
     Dec_Edge_t eRoot;
 
     // derive the cover from the SOP representation
     pCover = Dec_ConvertSopToMvc( pSop );
 
     // make sure the cover is CCS free (should be done before CST)
     Mvc_CoverContain( pCover );
     // check for trivial functions
     if ( Mvc_CoverIsEmpty(pCover) )
     {
         Mvc_CoverFree( pCover );
         return Dec_GraphCreateConst0();
     }
     if ( Mvc_CoverIsTautology(pCover) )
     {
         Mvc_CoverFree( pCover );
         return Dec_GraphCreateConst1();
     }
 
     // perform CST
     Mvc_CoverInverse( pCover ); // CST
     // start the factored form
     pFForm = Dec_GraphCreate( Abc_SopGetVarNum(pSop) );
     // factor the cover
     eRoot = Dec_Factor_rec( pFForm, pCover );
     // finalize the factored form
     Dec_GraphSetRoot( pFForm, eRoot );
     // complement the factored form if SOP is complemented
     if ( Abc_SopIsComplement(pSop) )
         Dec_GraphComplement( pFForm );
     // verify the factored form
 //    if ( !Dec_FactorVerify( pSop, pFForm ) )
 //        printf( "Verification has failed.\n" );
 //    Mvc_CoverInverse( pCover ); // undo CST
     Mvc_CoverFree( pCover );
     return pFForm;
 }

static Dec_Edge_t Dec_GraphAddNodeAnd	(	Dec_Graph_t *	pGraph,
		Dec_Edge_t	eEdge0,
		Dec_Edge_t	eEdge1
	)

inlinestatic

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

Synopsis [Creates an AND node.]

Description []

SideEffects []

SeeAlso []

Definition at line 591 of file dec.h.

 {
     Dec_Node_t * pNode;
     // get the new node
     pNode = Dec_GraphAppendNode( pGraph );
     // set the inputs and other info
     pNode->eEdge0 = eEdge0;
     pNode->eEdge1 = eEdge1;
     pNode->fCompl0 = eEdge0.fCompl;
     pNode->fCompl1 = eEdge1.fCompl;
     return Dec_EdgeCreate( pGraph->nSize - 1, 0 );
 }

static Dec_Edge_t Dec_GraphAddNodeMux	(	Dec_Graph_t *	pGraph,
		Dec_Edge_t	eEdgeC,
		Dec_Edge_t	eEdgeT,
		Dec_Edge_t	eEdgeE,
		int	Type
	)

inlinestatic

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

Synopsis [Creates an XOR node.]

Description []

SideEffects []

SeeAlso []

Definition at line 684 of file dec.h.

 {
     Dec_Edge_t eNode0, eNode1, eNode;
     if ( Type == 0 )
     {
         // derive the first AND
         eNode0 = Dec_GraphAddNodeAnd( pGraph, eEdgeC, eEdgeT );
         // derive the second AND
         eEdgeC.fCompl ^= 1;
         eNode1 = Dec_GraphAddNodeAnd( pGraph, eEdgeC, eEdgeE );
         // derive the final OR
         eNode = Dec_GraphAddNodeOr( pGraph, eNode0, eNode1 );
     }
     else
     {
         // complement the arguments
         eEdgeT.fCompl ^= 1;
         eEdgeE.fCompl ^= 1;
         // derive the first AND
         eNode0 = Dec_GraphAddNodeAnd( pGraph, eEdgeC, eEdgeT );
         // derive the second AND
         eEdgeC.fCompl ^= 1;
         eNode1 = Dec_GraphAddNodeAnd( pGraph, eEdgeC, eEdgeE );
         // derive the final OR
         eNode = Dec_GraphAddNodeOr( pGraph, eNode0, eNode1 );
         eNode.fCompl ^= 1;
     }
     return eNode;
 }

static Dec_Edge_t Dec_GraphAddNodeOr	(	Dec_Graph_t *	pGraph,
		Dec_Edge_t	eEdge0,
		Dec_Edge_t	eEdge1
	)

inlinestatic

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

Synopsis [Creates an OR node.]

Description []

SideEffects []

SeeAlso []

Definition at line 615 of file dec.h.

 {
     Dec_Node_t * pNode;
     // get the new node
     pNode = Dec_GraphAppendNode( pGraph );
     // set the inputs and other info
     pNode->eEdge0 = eEdge0;
     pNode->eEdge1 = eEdge1;
     pNode->fCompl0 = eEdge0.fCompl;
     pNode->fCompl1 = eEdge1.fCompl;
     // make adjustments for the OR gate
     pNode->fNodeOr = 1;
     pNode->eEdge0.fCompl = !pNode->eEdge0.fCompl;
     pNode->eEdge1.fCompl = !pNode->eEdge1.fCompl;
     return Dec_EdgeCreate( pGraph->nSize - 1, 1 );
 }

static Dec_Edge_t Dec_GraphAddNodeXor	(	Dec_Graph_t *	pGraph,
		Dec_Edge_t	eEdge0,
		Dec_Edge_t	eEdge1,
		int	Type
	)

inlinestatic

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

Synopsis [Creates an XOR node.]

Description []

SideEffects []

SeeAlso []

Definition at line 643 of file dec.h.

 {
     Dec_Edge_t eNode0, eNode1, eNode;
     if ( Type == 0 )
     {
         // derive the first AND
         eEdge0.fCompl ^= 1;
         eNode0 = Dec_GraphAddNodeAnd( pGraph, eEdge0, eEdge1 );
         eEdge0.fCompl ^= 1;
         // derive the second AND
         eEdge1.fCompl ^= 1;
         eNode1 = Dec_GraphAddNodeAnd( pGraph, eEdge0, eEdge1 );
         // derive the final OR
         eNode = Dec_GraphAddNodeOr( pGraph, eNode0, eNode1 );
     }
     else
     {
         // derive the first AND
         eNode0 = Dec_GraphAddNodeAnd( pGraph, eEdge0, eEdge1 );
         // derive the second AND
         eEdge0.fCompl ^= 1;
         eEdge1.fCompl ^= 1;
         eNode1 = Dec_GraphAddNodeAnd( pGraph, eEdge0, eEdge1 );
         // derive the final OR
         eNode = Dec_GraphAddNodeOr( pGraph, eNode0, eNode1 );
         eNode.fCompl ^= 1;
     }
     return eNode;
 }

static Dec_Node_t* Dec_GraphAppendNode ( Dec_Graph_t * pGraph )

inlinestatic

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

Synopsis [Appends a new node to the graph.]

Description [This procedure is meant for internal use.]

SideEffects []

SeeAlso []

Definition at line 567 of file dec.h.

 {
     Dec_Node_t * pNode;
     if ( pGraph->nSize == pGraph->nCap )
     {
         pGraph->pNodes = ABC_REALLOC( Dec_Node_t, pGraph->pNodes, 2 * pGraph->nCap ); 
         pGraph->nCap   = 2 * pGraph->nCap;
     }
     pNode = pGraph->pNodes + pGraph->nSize++;
     memset( pNode, 0, sizeof(Dec_Node_t) );
     return pNode;
 }

static void Dec_GraphComplement ( Dec_Graph_t * pGraph )

inlinestatic

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

Synopsis [Checks if the graph is complemented.]

Description []

SideEffects []

SeeAlso []

Definition at line 388 of file dec.h.

 {
     pGraph->eRoot.fCompl ^= 1;
 }

static Dec_Graph_t* Dec_GraphCreate ( int nLeaves )

inlinestatic

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

Synopsis [Creates a graph with the given number of leaves.]

Description []

SideEffects []

SeeAlso []

Definition at line 221 of file dec.h.

 {
     Dec_Graph_t * pGraph;
     pGraph = ABC_ALLOC( Dec_Graph_t, 1 );
     memset( pGraph, 0, sizeof(Dec_Graph_t) );
     pGraph->nLeaves = nLeaves;
     pGraph->nSize = nLeaves;
     pGraph->nCap = 2 * nLeaves + 50;
     pGraph->pNodes = ABC_ALLOC( Dec_Node_t, pGraph->nCap );
     memset( pGraph->pNodes, 0, sizeof(Dec_Node_t) * pGraph->nSize );
     return pGraph;
 }

static Dec_Graph_t* Dec_GraphCreateConst0 ( )

inlinestatic

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

Synopsis [Creates constant 0 graph.]

Description []

SideEffects []

SeeAlso []

Definition at line 245 of file dec.h.

 {
     Dec_Graph_t * pGraph;
     pGraph = ABC_ALLOC( Dec_Graph_t, 1 );
     memset( pGraph, 0, sizeof(Dec_Graph_t) );
     pGraph->fConst = 1;
     pGraph->eRoot.fCompl = 1;
     return pGraph;
 }

static Dec_Graph_t* Dec_GraphCreateConst1 ( )

inlinestatic

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

Synopsis [Creates constant 1 graph.]

Description []

SideEffects []

SeeAlso []

Definition at line 266 of file dec.h.

 {
     Dec_Graph_t * pGraph;
     pGraph = ABC_ALLOC( Dec_Graph_t, 1 );
     memset( pGraph, 0, sizeof(Dec_Graph_t) );
     pGraph->fConst = 1;
     return pGraph;
 }

static Dec_Graph_t* Dec_GraphCreateLeaf	(	int	iLeaf,
		int	nLeaves,
		int	fCompl
	)

inlinestatic

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

Synopsis [Creates the literal graph.]

Description []

SideEffects []

SeeAlso []

Definition at line 286 of file dec.h.

 {
     Dec_Graph_t * pGraph;
     assert( 0 <= iLeaf && iLeaf < nLeaves );
     pGraph = Dec_GraphCreate( nLeaves );
     pGraph->eRoot.Node   = iLeaf;
     pGraph->eRoot.fCompl = fCompl;
     return pGraph;
 }

unsigned Dec_GraphDeriveTruth ( Dec_Graph_t * pGraph )

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

Synopsis [Derives the truth table.]

Description []

SideEffects []

SeeAlso []

Definition at line 95 of file decUtil.c.

 {
     unsigned uTruths[5] = { 0xAAAAAAAA, 0xCCCCCCCC, 0xF0F0F0F0, 0xFF00FF00, 0xFFFF0000 };
     unsigned uTruth = 0; // Suppress "might be used uninitialized"
     unsigned uTruth0, uTruth1;
     Dec_Node_t * pNode;
     int i;
 
     // sanity checks
     assert( Dec_GraphLeaveNum(pGraph) >= 0 );
     assert( Dec_GraphLeaveNum(pGraph) <= pGraph->nSize );
     assert( Dec_GraphLeaveNum(pGraph) <= 5 );
 
     // check for constant function
     if ( Dec_GraphIsConst(pGraph) )
         return Dec_GraphIsComplement(pGraph)? 0 : ~((unsigned)0);
     // check for a literal
     if ( Dec_GraphIsVar(pGraph) )
         return Dec_GraphIsComplement(pGraph)? ~uTruths[Dec_GraphVarInt(pGraph)] : uTruths[Dec_GraphVarInt(pGraph)];
 
     // assign the elementary variables
     Dec_GraphForEachLeaf( pGraph, pNode, i )
         pNode->pFunc = (void *)(ABC_PTRUINT_T)uTruths[i];
 
     // compute the function for each internal node
     Dec_GraphForEachNode( pGraph, pNode, i )
     {
         uTruth0 = (unsigned)(ABC_PTRUINT_T)Dec_GraphNode(pGraph, pNode->eEdge0.Node)->pFunc;
         uTruth1 = (unsigned)(ABC_PTRUINT_T)Dec_GraphNode(pGraph, pNode->eEdge1.Node)->pFunc;
         uTruth0 = pNode->eEdge0.fCompl? ~uTruth0 : uTruth0;
         uTruth1 = pNode->eEdge1.fCompl? ~uTruth1 : uTruth1;
         uTruth = uTruth0 & uTruth1;
         pNode->pFunc = (void *)(ABC_PTRUINT_T)uTruth;
     }
 
     // complement the result if necessary
     return Dec_GraphIsComplement(pGraph)? ~uTruth : uTruth;
 }

static void Dec_GraphFree ( Dec_Graph_t * pGraph )

inlinestatic

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

Synopsis [Creates a graph with the given number of leaves.]

Description []

SideEffects []

SeeAlso []

Definition at line 307 of file dec.h.

 {
     ABC_FREE( pGraph->pNodes );
     ABC_FREE( pGraph );
 }

static int Dec_GraphIsComplement ( Dec_Graph_t * pGraph )

inlinestatic

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

Synopsis [Returns 1 if the graph is complemented.]

Description []

SideEffects []

SeeAlso []

Definition at line 372 of file dec.h.

 {
     return pGraph->eRoot.fCompl;
 }

static int Dec_GraphIsConst ( Dec_Graph_t * pGraph )

inlinestatic

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

Synopsis [Returns 1 if the graph is a constant.]

Description []

SideEffects []

SeeAlso []

Definition at line 324 of file dec.h.

 {
     return pGraph->fConst;
 }

static int Dec_GraphIsConst0 ( Dec_Graph_t * pGraph )

inlinestatic

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

Synopsis [Returns 1 if the graph is constant 0.]

Description []

SideEffects []

SeeAlso []

Definition at line 340 of file dec.h.

 {
     return pGraph->fConst && pGraph->eRoot.fCompl;
 }

static int Dec_GraphIsConst1 ( Dec_Graph_t * pGraph )

inlinestatic

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

Synopsis [Returns 1 if the graph is constant 1.]

Description []

SideEffects []

SeeAlso []

Definition at line 356 of file dec.h.

 {
     return pGraph->fConst && !pGraph->eRoot.fCompl;
 }

static int Dec_GraphIsVar ( Dec_Graph_t * pGraph )

inlinestatic

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

Synopsis [Check if the graph represents elementary variable.]

Description []

SideEffects []

SeeAlso []

Definition at line 485 of file dec.h.

 {
     return pGraph->eRoot.Node < (unsigned)pGraph->nLeaves;
 }

static int Dec_GraphLeaveNum ( Dec_Graph_t * pGraph )

inlinestatic

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

Synopsis [Returns the number of leaves.]

Description []

SideEffects []

SeeAlso []

Definition at line 405 of file dec.h.

 {
     return pGraph->nLeaves;
 }

static Dec_Node_t* Dec_GraphNode	(	Dec_Graph_t *	pGraph,
		int	i
	)

inlinestatic

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

Synopsis [Returns the pointer to the node.]

Description []

SideEffects []

SeeAlso []

Definition at line 437 of file dec.h.

 {
     return pGraph->pNodes + i;
 }

static int Dec_GraphNodeInt	(	Dec_Graph_t *	pGraph,
		Dec_Node_t *	pNode
	)

inlinestatic

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

Synopsis [Returns the number of the given node.]

Description []

SideEffects []

SeeAlso []

Definition at line 469 of file dec.h.

 {
     return pNode - pGraph->pNodes;
 }

static int Dec_GraphNodeIsVar	(	Dec_Graph_t *	pGraph,
		Dec_Node_t *	pNode
	)

inlinestatic

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

Synopsis [Check if the graph represents elementary variable.]

Description []

SideEffects []

SeeAlso []

Definition at line 501 of file dec.h.

 {
     return Dec_GraphNodeInt(pGraph,pNode) < pGraph->nLeaves;
 }

static Dec_Node_t* Dec_GraphNodeLast ( Dec_Graph_t * pGraph )

inlinestatic

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

Synopsis [Returns the pointer to the node.]

Description []

SideEffects []

SeeAlso []

Definition at line 453 of file dec.h.

 {
     return pGraph->pNodes + pGraph->nSize - 1;
 }

static int Dec_GraphNodeNum ( Dec_Graph_t * pGraph )

inlinestatic

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

Synopsis [Returns the number of internal nodes.]

Description []

SideEffects []

SeeAlso []

Definition at line 421 of file dec.h.

 {
     return pGraph->nSize - pGraph->nLeaves;
 }

void Dec_GraphPrint	(	FILE *	pFile,
		Dec_Graph_t *	pGraph,
		char *	pNamesIn[],
		char *	pNameOut
	)

FUNCTION DEFINITIONS ///.

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

Synopsis [Prints the decomposition graph.]

Description []

SideEffects []

SeeAlso []

Definition at line 49 of file decPrint.c.

 {
     Vec_Ptr_t * vNamesIn = NULL;
     int LitSizeMax, LitSizeCur, Pos, i;
 
     // create the names if not given by the user
     if ( pNamesIn == NULL )
     {
         vNamesIn = Abc_NodeGetFakeNames( Dec_GraphLeaveNum(pGraph) );
         pNamesIn = (char **)vNamesIn->pArray;
     }
     if ( pNameOut == NULL )
         pNameOut = "F";
 
     // get the size of the longest literal
     LitSizeMax = 0;
     for ( i = 0; i < Dec_GraphLeaveNum(pGraph); i++ )
     {
         LitSizeCur = strlen(pNamesIn[i]);
         if ( LitSizeMax < LitSizeCur )
             LitSizeMax = LitSizeCur;
     }
     if ( LitSizeMax > 50 )
         LitSizeMax = 20;
 
     // write the decomposition graph (factored form)
     if ( Dec_GraphIsConst(pGraph) ) // constant
     {
         Pos = Dec_GraphPrintOutputName( pFile, pNameOut );
         fprintf( pFile, "Constant %d", !Dec_GraphIsComplement(pGraph) );
     }
     else if ( Dec_GraphIsVar(pGraph) ) // literal
     {
         Pos = Dec_GraphPrintOutputName( pFile, pNameOut );
         Dec_GraphPrintGetLeafName( pFile, Dec_GraphVarInt(pGraph), Dec_GraphIsComplement(pGraph), pNamesIn );
     }
     else
     {
         Pos = Dec_GraphPrintOutputName( pFile, pNameOut );
         Dec_GraphPrint_rec( pFile, pGraph, Dec_GraphNodeLast(pGraph), Dec_GraphIsComplement(pGraph), pNamesIn, &Pos, LitSizeMax );
     }
     fprintf( pFile, "\n" );
 
     if ( vNamesIn )
         Abc_NodeFreeNames( vNamesIn );
 }

static void Dec_GraphSetRoot	(	Dec_Graph_t *	pGraph,
		Dec_Edge_t	eRoot
	)

inlinestatic

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

Synopsis [Sets the root of the graph.]

Description []

SideEffects []

SeeAlso []

Definition at line 551 of file dec.h.

 {
     pGraph->eRoot = eRoot;
 }

static Dec_Node_t* Dec_GraphVar ( Dec_Graph_t * pGraph )

inlinestatic

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

Synopsis [Returns the elementary variable elementary variable.]

Description []

SideEffects []

SeeAlso []

Definition at line 517 of file dec.h.

 {
     assert( Dec_GraphIsVar( pGraph ) );
     return Dec_GraphNode( pGraph, pGraph->eRoot.Node );
 }

static int Dec_GraphVarInt ( Dec_Graph_t * pGraph )

inlinestatic

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

Synopsis [Returns the number of the elementary variable.]

Description []

SideEffects []

SeeAlso []

Definition at line 534 of file dec.h.

 {
     assert( Dec_GraphIsVar( pGraph ) );
     return Dec_GraphNodeInt( pGraph, Dec_GraphVar(pGraph) );
 }

static Dec_Edge_t Dec_IntToEdge ( unsigned Edge )

inlinestatic

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

Synopsis [Converts unsigned integer into the edge.]

Description []

SideEffects []

SeeAlso []

Definition at line 167 of file dec.h.

 {
     return Dec_EdgeCreate( Edge >> 1, Edge & 1 ); 
 }

static Dec_Edge_t Dec_IntToEdge_ ( unsigned m )

inlinestatic

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

Synopsis [Converts unsigned integer into the edge.]

Description []

SideEffects []

SeeAlso []

Definition at line 202 of file dec.h.

202 { union { Dec_Edge_t x; unsigned y; } v; v.y = m; return v.x; }

Dec_Edge_t

typedefABC_NAMESPACE_HEADER_START struct Dec_Edge_t_ Dec_Edge_t

INCLUDES ///.

Definition: dec.h:42

Dec_Man_t* Dec_ManStart ( )

DECLARATIONS ///.

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

FileName [decMan.c]

PackageName [MVSIS 2.0: Multi-valued logic synthesis system.]

Synopsis [Decomposition manager.]

Author [MVSIS Group]

Affiliation [UC Berkeley]

Date [Ver. 1.0. Started - February 1, 2003.]

Revision [

Id:: decMan.c,v 1.1 2003/05/22 19:20:05 alanmi Exp

]FUNCTION DEFINITIONS /// Function*************************************************************

Synopsis [Start the MVC manager used in the factoring package.]

Description []

SideEffects []

SeeAlso []

Definition at line 45 of file decMan.c.

 {
     Dec_Man_t * p;
 //    abctime clk = Abc_Clock();
     p = ABC_ALLOC( Dec_Man_t, 1 );
     p->pMvcMem = Mvc_ManagerStart();
     p->vCubes = Vec_IntAlloc( 8 );
     p->vLits = Vec_IntAlloc( 8 );
     // canonical forms, phases, perms
     Extra_Truth4VarNPN( &p->puCanons, &p->pPhases, &p->pPerms, &p->pMap );
 //ABC_PRT( "NPN classes precomputation time", Abc_Clock() - clk ); 
     return p;
 }

void Dec_ManStop ( Dec_Man_t * p )

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

Synopsis [Stops the MVC maanager used in the factoring package.]

Description []

SideEffects []

SeeAlso []

Definition at line 70 of file decMan.c.

 {
     Mvc_ManagerFree( (Mvc_Manager_t *)p->pMvcMem );
     Vec_IntFree( p->vCubes );
     Vec_IntFree( p->vLits );
     ABC_FREE( p->puCanons );
     ABC_FREE( p->pPhases );
     ABC_FREE( p->pPerms );
     ABC_FREE( p->pMap );
     ABC_FREE( p );
 }

Data Structures

Macros

Typedefs

Functions

Macro Definition Documentation

Typedef Documentation

Function Documentation