#include <stdio.h>
#include "misc/extra/extra.h"
#include "misc/vec/vec.h"
#include "cut.h"
#include "cutList.h"

Data Structures
struct	Cut_ManStruct_t_

Macros
#define	Cut_ListForEachCut(pList, pCut)

#define	Cut_ListForEachCutStop(pList, pCut, pStop)

#define	Cut_ListForEachCutSafe(pList, pCut, pCut2)

Typedefs
typedef typedefABC_NAMESPACE_HEADER_START struct Cut_HashTableStruct_t_	Cut_HashTable_t
	INCLUDES ///. More...

Functions
static unsigned	Cut_NodeSign (int Node)
	MACRO DEFINITIONS ///. More...

static int	Cut_TruthWords (int nVarsMax)

Cut_Cut_t *	Cut_CutAlloc (Cut_Man_t *p)
	FUNCTION DECLARATIONS ///. More...

void	Cut_CutRecycle (Cut_Man_t p, Cut_Cut_t pCut)

int	Cut_CutCompare (Cut_Cut_t pCut1, Cut_Cut_t pCut2)

Cut_Cut_t *	Cut_CutDupList (Cut_Man_t p, Cut_Cut_t pList)

void	Cut_CutRecycleList (Cut_Man_t p, Cut_Cut_t pList)

Cut_Cut_t *	Cut_CutMergeLists (Cut_Cut_t pList1, Cut_Cut_t pList2)

void	Cut_CutNumberList (Cut_Cut_t *pList)

Cut_Cut_t *	Cut_CutCreateTriv (Cut_Man_t *p, int Node)

void	Cut_CutPrintMerge (Cut_Cut_t pCut, Cut_Cut_t pCut0, Cut_Cut_t *pCut1)

Cut_Cut_t *	Cut_CutMergeTwo (Cut_Man_t p, Cut_Cut_t pCut0, Cut_Cut_t *pCut1)

void	Cut_NodeDoComputeCuts (Cut_Man_t p, Cut_List_t pSuper, int Node, int fCompl0, int fCompl1, Cut_Cut_t pList0, Cut_Cut_t pList1, int fTriv, int TreeCode)

int	Cut_CutListVerify (Cut_Cut_t *pList)

Cut_HashTable_t *	Cut_TableStart (int Size)

void	Cut_TableStop (Cut_HashTable_t *pTable)

int	Cut_TableLookup (Cut_HashTable_t pTable, Cut_Cut_t pCut, int fStore)

void	Cut_TableClear (Cut_HashTable_t *pTable)

int	Cut_TableReadTime (Cut_HashTable_t *pTable)

void	Cut_TruthComputeOld (Cut_Cut_t pCut, Cut_Cut_t pCut0, Cut_Cut_t *pCut1, int fCompl0, int fCompl1)

void	Cut_TruthCompute (Cut_Man_t p, Cut_Cut_t pCut, Cut_Cut_t pCut0, Cut_Cut_t pCut1, int fCompl0, int fCompl1)

Macro Definition Documentation

#define Cut_ListForEachCut	(	pList,
		pCut
	)

Value:

for ( pCut = pList;                                   \
          pCut;                                           \
          pCut = pCut->pNext )

Definition at line 104 of file cutInt.h.

#define Cut_ListForEachCutSafe	(	pList,
		pCut,
		pCut2
	)

Value:

for ( pCut = pList,                                   \
          pCut2 = pCut? pCut->pNext: NULL;                \
          pCut;                                           \
          pCut = pCut2,                                   \
          pCut2 = pCut? pCut->pNext: NULL )

Definition at line 112 of file cutInt.h.

#define Cut_ListForEachCutStop	(	pList,
		pCut,
		pStop
	)

Value:

for ( pCut = pList;                                   \
          pCut != pStop;                                  \
          pCut = pCut->pNext )

Definition at line 108 of file cutInt.h.

Typedef Documentation

typedef typedefABC_NAMESPACE_HEADER_START struct Cut_HashTableStruct_t_ Cut_HashTable_t

INCLUDES ///.

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

FileName [cutInt.h]

SystemName [ABC: Logic synthesis and verification system.]

PackageName [K-feasible cut computation package.]

Synopsis [External declarations.]

Author [Alan Mishchenko]

Affiliation [UC Berkeley]

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

Revision [

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

]PARAMETERS ///BASIC TYPES ///

Definition at line 46 of file cutInt.h.

Function Documentation

Cut_Cut_t* Cut_CutAlloc ( Cut_Man_t * p )

FUNCTION DECLARATIONS ///.

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

FileName [cutNode.c]

SystemName [ABC: Logic synthesis and verification system.]

PackageName [K-feasible cut computation package.]

Synopsis [Procedures to compute cuts for a node.]

Author [Alan Mishchenko]

Affiliation [UC Berkeley]

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

Revision [

Id:: cutNode.c,v 1.00 2005/06/20 00:00:00 alanmi Exp

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

Synopsis [Allocates the cut.]

Description []

SideEffects []

SeeAlso []

Definition at line 45 of file cutCut.c.

 {
     Cut_Cut_t * pCut;
     // cut allocation
     pCut = (Cut_Cut_t *)Extra_MmFixedEntryFetch( p->pMmCuts );
     memset( pCut, 0, sizeof(Cut_Cut_t) );
     pCut->nVarsMax   = p->pParams->nVarsMax;
     pCut->fSimul     = p->fSimul;
     // statistics
     p->nCutsAlloc++;
     p->nCutsCur++;
     if ( p->nCutsPeak < p->nCutsAlloc - p->nCutsDealloc )
         p->nCutsPeak = p->nCutsAlloc - p->nCutsDealloc;
     return pCut;
 }

int Cut_CutCompare	(	Cut_Cut_t *	pCut1,
		Cut_Cut_t *	pCut2
	)

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

Synopsis [Compares two cuts.]

Description []

SideEffects []

SeeAlso []

Definition at line 92 of file cutCut.c.

 {
     int i;
     if ( pCut1->nLeaves < pCut2->nLeaves )
         return -1;
     if ( pCut1->nLeaves > pCut2->nLeaves )
         return 1;
     for ( i = 0; i < (int)pCut1->nLeaves; i++ )
     {
         if ( pCut1->pLeaves[i] < pCut2->pLeaves[i] )
             return -1;
         if ( pCut1->pLeaves[i] > pCut2->pLeaves[i] )
             return 1;
     }
     return 0;
 }

Cut_Cut_t* Cut_CutCreateTriv	(	Cut_Man_t *	p,
		int	Node
	)

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

Synopsis [Creates the trivial cut.]

Description []

SideEffects []

SeeAlso []

Definition at line 238 of file cutCut.c.

 {
     Cut_Cut_t * pCut;
     if ( p->pParams->fSeq )
         Node <<= CUT_SHIFT;
     pCut = Cut_CutAlloc( p );
     pCut->nLeaves    = 1;
     pCut->pLeaves[0] = Node;
     pCut->uSign      = Cut_NodeSign( Node );
     if ( p->pParams->fTruth )
     {
 /*
         if ( pCut->nVarsMax == 4 )
             Cut_CutWriteTruth( pCut, p->uTruthVars[0] );
         else
             Extra_BitCopy( pCut->nLeaves, p->uTruths[0], (uint8*)Cut_CutReadTruth(pCut) );
 */
         unsigned * pTruth = Cut_CutReadTruth(pCut);
         int i;
         for ( i = 0; i < p->nTruthWords; i++ )
             pTruth[i] = 0xAAAAAAAA;
     }
     p->nCutsTriv++;
     return pCut;
 } 

Cut_Cut_t* Cut_CutDupList	(	Cut_Man_t *	p,
		Cut_Cut_t *	pList
	)

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

Synopsis [Duplicates the list.]

Description []

SideEffects []

SeeAlso []

Definition at line 120 of file cutCut.c.

 {
     Cut_Cut_t * pHead = NULL, ** ppTail = &pHead;
     Cut_Cut_t * pTemp, * pCopy;
     if ( pList == NULL )
         return NULL;
     Cut_ListForEachCut( pList, pTemp )
     {
         pCopy = (Cut_Cut_t *)Extra_MmFixedEntryFetch( p->pMmCuts );
         memcpy( pCopy, pTemp, p->EntrySize );
         *ppTail = pCopy;
         ppTail = &pCopy->pNext;
     }
     *ppTail = NULL;
     return pHead;
 }

int Cut_CutListVerify ( Cut_Cut_t * pList )

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

Synopsis [Verifies that the list contains only non-dominated cuts.]

Description []

SideEffects []

SeeAlso []

Definition at line 979 of file cutNode.c.

 { 
     Cut_Cut_t * pCut, * pDom;
     Cut_ListForEachCut( pList, pCut )
     {
         Cut_ListForEachCutStop( pList, pDom, pCut )
         {
             if ( Cut_CutCheckDominance( pDom, pCut ) )
             {
                 printf( "******************* These are contained cuts:\n" );
                 Cut_CutPrint( pDom, 1 );
                 Cut_CutPrint( pDom, 1 );
                 return 0;
             }
         }
     }
     return 1;
 }

Cut_Cut_t* Cut_CutMergeLists	(	Cut_Cut_t *	pList1,
		Cut_Cut_t *	pList2
	)

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

Synopsis [Merges two NULL-terminated linked lists.]

Description []

SideEffects []

SeeAlso []

Definition at line 185 of file cutCut.c.

 {
     Cut_Cut_t * pList = NULL, ** ppTail = &pList;
     Cut_Cut_t * pCut;
     while ( pList1 && pList2 )
     {
         if ( Cut_CutCompare(pList1, pList2) < 0 )
         {
             pCut = pList1;
             pList1 = pList1->pNext;
         }
         else
         {
             pCut = pList2;
             pList2 = pList2->pNext;
         }
         *ppTail = pCut;
         ppTail = &pCut->pNext;
     }
     *ppTail = pList1? pList1: pList2;
     return pList;
 }

Cut_Cut_t* Cut_CutMergeTwo	(	Cut_Man_t *	p,
		Cut_Cut_t *	pCut0,
		Cut_Cut_t *	pCut1
	)

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

Synopsis [Merges two cuts.]

Description []

SideEffects []

SeeAlso []

Definition at line 170 of file cutMerge.c.

 { 
     Cut_Cut_t * pRes;
     int * pLeaves;
     int Limit, nLeaves0, nLeaves1;
     int i, k, c;
 
     assert( pCut0->nLeaves >= pCut1->nLeaves );
 
     // consider two cuts
     nLeaves0 = pCut0->nLeaves;
     nLeaves1 = pCut1->nLeaves;
 
     // the case of the largest cut sizes
     Limit = p->pParams->nVarsMax;
     if ( nLeaves0 == Limit && nLeaves1 == Limit )
     {
         for ( i = 0; i < nLeaves0; i++ )
             if ( pCut0->pLeaves[i] != pCut1->pLeaves[i] )
                 return NULL;
         pRes = Cut_CutAlloc( p );
         for ( i = 0; i < nLeaves0; i++ )
             pRes->pLeaves[i] = pCut0->pLeaves[i];
         pRes->nLeaves = pCut0->nLeaves;
         return pRes;
     }
     // the case when one of the cuts is the largest
     if ( nLeaves0 == Limit )
     {
         for ( i = 0; i < nLeaves1; i++ )
         {
             for ( k = nLeaves0 - 1; k >= 0; k-- )
                 if ( pCut0->pLeaves[k] == pCut1->pLeaves[i] )
                     break;
             if ( k == -1 ) // did not find
                 return NULL;
         }
         pRes = Cut_CutAlloc( p );
         for ( i = 0; i < nLeaves0; i++ )
             pRes->pLeaves[i] = pCut0->pLeaves[i];
         pRes->nLeaves = pCut0->nLeaves;
         return pRes;
     }
 
     // prepare the cut
     if ( p->pReady == NULL )
         p->pReady = Cut_CutAlloc( p );
     pLeaves = p->pReady->pLeaves;
 
     // compare two cuts with different numbers
     i = k = 0;
     for ( c = 0; c < Limit; c++ )
     {
         if ( k == nLeaves1 )
         {
             if ( i == nLeaves0 )
             {
                 p->pReady->nLeaves = c;
                 pRes = p->pReady;  p->pReady = NULL;
                 return pRes;
             }
             pLeaves[c] = pCut0->pLeaves[i++];
             continue;
         }
         if ( i == nLeaves0 )
         {
             if ( k == nLeaves1 )
             {
                 p->pReady->nLeaves = c;
                 pRes = p->pReady;  p->pReady = NULL;
                 return pRes;
             }
             pLeaves[c] = pCut1->pLeaves[k++];
             continue;
         }
         if ( pCut0->pLeaves[i] < pCut1->pLeaves[k] )
         {
             pLeaves[c] = pCut0->pLeaves[i++];
             continue;
         }
         if ( pCut0->pLeaves[i] > pCut1->pLeaves[k] )
         {
             pLeaves[c] = pCut1->pLeaves[k++];
             continue;
         }
         pLeaves[c] = pCut0->pLeaves[i++]; 
         k++;
     }
     if ( i < nLeaves0 || k < nLeaves1 )
         return NULL;
     p->pReady->nLeaves = c;
     pRes = p->pReady;  p->pReady = NULL;
     return pRes;
 }

void Cut_CutNumberList ( Cut_Cut_t * pList )

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

Synopsis [Sets the number of the cuts in the list.]

Description []

SideEffects []

SeeAlso []

Definition at line 219 of file cutCut.c.

 {
     Cut_Cut_t * pCut;
     int i = 0;
     Cut_ListForEachCut( pList, pCut )
         pCut->Num0 = i++;
 }

void Cut_CutPrintMerge	(	Cut_Cut_t *	pCut,
		Cut_Cut_t *	pCut0,
		Cut_Cut_t *	pCut1
	)

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

Synopsis [Consider dropping cuts if they are useless by now.]

Description []

SideEffects []

SeeAlso []

Definition at line 326 of file cutCut.c.

 {
     printf( "\n" );
     printf( "%d : %5d %5d %5d %5d %5d\n", 
         pCut0->nLeaves, 
         pCut0->nLeaves > 0 ? pCut0->pLeaves[0] : -1, 
         pCut0->nLeaves > 1 ? pCut0->pLeaves[1] : -1, 
         pCut0->nLeaves > 2 ? pCut0->pLeaves[2] : -1, 
         pCut0->nLeaves > 3 ? pCut0->pLeaves[3] : -1, 
         pCut0->nLeaves > 4 ? pCut0->pLeaves[4] : -1
         );
     printf( "%d : %5d %5d %5d %5d %5d\n", 
         pCut1->nLeaves, 
         pCut1->nLeaves > 0 ? pCut1->pLeaves[0] : -1, 
         pCut1->nLeaves > 1 ? pCut1->pLeaves[1] : -1, 
         pCut1->nLeaves > 2 ? pCut1->pLeaves[2] : -1, 
         pCut1->nLeaves > 3 ? pCut1->pLeaves[3] : -1, 
         pCut1->nLeaves > 4 ? pCut1->pLeaves[4] : -1
         );
     if ( pCut == NULL )
         printf( "Cannot merge\n" );
     else
         printf( "%d : %5d %5d %5d %5d %5d\n", 
             pCut->nLeaves, 
             pCut->nLeaves > 0 ? pCut->pLeaves[0] : -1, 
             pCut->nLeaves > 1 ? pCut->pLeaves[1] : -1, 
             pCut->nLeaves > 2 ? pCut->pLeaves[2] : -1, 
             pCut->nLeaves > 3 ? pCut->pLeaves[3] : -1, 
             pCut->nLeaves > 4 ? pCut->pLeaves[4] : -1
             );
 }

void Cut_CutRecycle	(	Cut_Man_t *	p,
		Cut_Cut_t *	pCut
	)

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

Synopsis [Recybles the cut.]

Description []

SideEffects []

SeeAlso []

Definition at line 72 of file cutCut.c.

 {
     p->nCutsDealloc++;
     p->nCutsCur--;
     if ( pCut->nLeaves == 1 )
         p->nCutsTriv--;
     Extra_MmFixedEntryRecycle( p->pMmCuts, (char *)pCut );
 }

void Cut_CutRecycleList	(	Cut_Man_t *	p,
		Cut_Cut_t *	pList
	)

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

Synopsis [Recycles the list.]

Description []

SideEffects []

SeeAlso []

Definition at line 148 of file cutCut.c.

 {
     Cut_Cut_t * pCut, * pCut2;
     Cut_ListForEachCutSafe( pList, pCut, pCut2 )
         Extra_MmFixedEntryRecycle( p->pMmCuts, (char *)pCut );
 }

void Cut_NodeDoComputeCuts	(	Cut_Man_t *	p,
		Cut_List_t *	pSuper,
		int	Node,
		int	fCompl0,
		int	fCompl1,
		Cut_Cut_t *	pList0,
		Cut_Cut_t *	pList1,
		int	fTriv,
		int	TreeCode
	)

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

Synopsis [Computes the cuts by merging cuts at two nodes.]

Description []

SideEffects []

SeeAlso []

Definition at line 572 of file cutNode.c.

 {
     Cut_Cut_t * pStop0, * pStop1, * pTemp0, * pTemp1;
     Cut_Cut_t * pStore0 = NULL, * pStore1 = NULL; // Suppress "might be used uninitialized"
     int i, nCutsOld, Limit;
     // start with the elementary cut
     if ( fTriv ) 
     {
 //        printf( "Creating trivial cut %d.\n", Node );
         pTemp0 = Cut_CutCreateTriv( p, Node );
         Cut_ListAdd( pSuper, pTemp0 );
         p->nNodeCuts++;
     }
     // get the cut lists of children
     if ( pList0 == NULL || pList1 == NULL || (p->pParams->fLocal && TreeCode)  )
         return;
 
     // remember the old number of cuts
     nCutsOld = p->nCutsCur;
     Limit = p->pParams->nVarsMax;
     // get the simultation bit of the node
     p->fSimul = (fCompl0 ^ pList0->fSimul) & (fCompl1 ^ pList1->fSimul);
     // set temporary variables
     p->fCompl0 = fCompl0;
     p->fCompl1 = fCompl1;
     // if tree cuts are computed, make sure only the unit cuts propagate over the DAG nodes
     if ( TreeCode & 1 )
     {
         assert( pList0->nLeaves == 1 );
         pStore0 = pList0->pNext;
         pList0->pNext = NULL;
     }
     if ( TreeCode & 2 )
     {
         assert( pList1->nLeaves == 1 );
         pStore1 = pList1->pNext;
         pList1->pNext = NULL;
     }
     // find the point in the list where the max-var cuts begin
     Cut_ListForEachCut( pList0, pStop0 )
         if ( pStop0->nLeaves == (unsigned)Limit )
             break;
     Cut_ListForEachCut( pList1, pStop1 )
         if ( pStop1->nLeaves == (unsigned)Limit )
             break;
 
     // small by small
     Cut_ListForEachCutStop( pList0, pTemp0, pStop0 )
     Cut_ListForEachCutStop( pList1, pTemp1, pStop1 )
     {
         if ( Cut_CutProcessTwo( p, pTemp0, pTemp1, pSuper ) )
             goto Quits;
     }
     // small by large
     Cut_ListForEachCutStop( pList0, pTemp0, pStop0 )
     Cut_ListForEachCut( pStop1, pTemp1 )
     {
         if ( (pTemp0->uSign & pTemp1->uSign) != pTemp0->uSign )
             continue;
         if ( Cut_CutProcessTwo( p, pTemp0, pTemp1, pSuper ) )
             goto Quits;
     }
     // small by large
     Cut_ListForEachCutStop( pList1, pTemp1, pStop1 )
     Cut_ListForEachCut( pStop0, pTemp0 )
     {
         if ( (pTemp0->uSign & pTemp1->uSign) != pTemp1->uSign )
             continue;
         if ( Cut_CutProcessTwo( p, pTemp0, pTemp1, pSuper ) )
             goto Quits;
     }
     // large by large
     Cut_ListForEachCut( pStop0, pTemp0 )
     Cut_ListForEachCut( pStop1, pTemp1 )
     {
         assert( pTemp0->nLeaves == (unsigned)Limit && pTemp1->nLeaves == (unsigned)Limit );
         if ( pTemp0->uSign != pTemp1->uSign )
             continue;
         for ( i = 0; i < Limit; i++ )
             if ( pTemp0->pLeaves[i] != pTemp1->pLeaves[i] )
                 break;
         if ( i < Limit )
             continue;
         if ( Cut_CutProcessTwo( p, pTemp0, pTemp1, pSuper ) )
             goto Quits;
     } 
     if ( p->nNodeCuts == 0 )
         p->nNodesNoCuts++;
 Quits:
     if ( TreeCode & 1 )
         pList0->pNext = pStore0;
     if ( TreeCode & 2 )
         pList1->pNext = pStore1;
 }

static unsigned Cut_NodeSign ( int Node )

inlinestatic

MACRO DEFINITIONS ///.

Definition at line 124 of file cutInt.h.

124 { return (1 << (Node % 31)); }

void Cut_TableClear ( Cut_HashTable_t * pTable )

int Cut_TableLookup	(	Cut_HashTable_t *	pTable,
		Cut_Cut_t *	pCut,
		int	fStore
	)

int Cut_TableReadTime ( Cut_HashTable_t * pTable )

Cut_HashTable_t* Cut_TableStart ( int Size )

void Cut_TableStop ( Cut_HashTable_t * pTable )

void Cut_TruthCompute	(	Cut_Man_t *	p,
		Cut_Cut_t *	pCut,
		Cut_Cut_t *	pCut0,
		Cut_Cut_t *	pCut1,
		int	fCompl0,
		int	fCompl1
	)

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

Synopsis [Performs truth table computation.]

Description []

SideEffects []

SeeAlso []

Definition at line 177 of file cutTruth.c.

 {
     // permute the first table
     if ( fCompl0 ) 
         Extra_TruthNot( p->puTemp[0], Cut_CutReadTruth(pCut0), pCut->nVarsMax );
     else
         Extra_TruthCopy( p->puTemp[0], Cut_CutReadTruth(pCut0), pCut->nVarsMax );
     Extra_TruthStretch( p->puTemp[2], p->puTemp[0], pCut0->nLeaves, pCut->nVarsMax, Cut_TruthPhase(pCut, pCut0) );
     // permute the second table
     if ( fCompl1 ) 
         Extra_TruthNot( p->puTemp[1], Cut_CutReadTruth(pCut1), pCut->nVarsMax );
     else
         Extra_TruthCopy( p->puTemp[1], Cut_CutReadTruth(pCut1), pCut->nVarsMax );
     Extra_TruthStretch( p->puTemp[3], p->puTemp[1], pCut1->nLeaves, pCut->nVarsMax, Cut_TruthPhase(pCut, pCut1) );
     // produce the resulting table
     if ( pCut->fCompl )
         Extra_TruthNand( Cut_CutReadTruth(pCut), p->puTemp[2], p->puTemp[3], pCut->nVarsMax );
     else
         Extra_TruthAnd( Cut_CutReadTruth(pCut), p->puTemp[2], p->puTemp[3], pCut->nVarsMax );
 
 //    Ivy_TruthTestOne( *Cut_CutReadTruth(pCut) );
 
     // quit if no fancy computation is needed
     if ( !p->pParams->fFancy )
         return;
 
     if ( pCut->nLeaves != 7 )
         return;
 
     // count the total number of truth tables computed
     nTotal++;
 
     // MAPPING INTO ALTERA 6-2 LOGIC BLOCKS
     // call this procedure to find the minimum number of common variables in the cofactors
     // if this number is less or equal than 3, the cut can be implemented using the 6-2 logic block
     if ( Extra_TruthMinCofSuppOverlap( Cut_CutReadTruth(pCut), pCut->nVarsMax, NULL ) <= 4 )
         nGood++;
 
     // MAPPING INTO ACTEL 2x2 CELLS
     // call this procedure to see if a semi-canonical form can be found in the lookup table 
     // (if it exists, then a two-level 3-input LUT implementation of the cut exists)
     // Before this procedure is called, cell manager should be defined by calling
     // Cut_CellLoad (make sure file "cells22_daomap_iwls.txt" is available in the working dir)
 //    if ( Cut_CellIsRunning() && pCut->nVarsMax <= 9 )
 //        nGood += Cut_CellTruthLookup( Cut_CutReadTruth(pCut), pCut->nVarsMax );
 }

void Cut_TruthComputeOld	(	Cut_Cut_t *	pCut,
		Cut_Cut_t *	pCut0,
		Cut_Cut_t *	pCut1,
		int	fCompl0,
		int	fCompl1
	)

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

Synopsis [Performs truth table computation.]

Description []

SideEffects []

SeeAlso []

Definition at line 126 of file cutTruth.c.

 {
     static unsigned uTruth0[8], uTruth1[8];
     int nTruthWords = Cut_TruthWords( pCut->nVarsMax );
     unsigned * pTruthRes;
     int i, uPhase;
 
     // permute the first table
     uPhase = Cut_TruthPhase( pCut, pCut0 );
     Extra_TruthExpand( pCut->nVarsMax, nTruthWords, Cut_CutReadTruth(pCut0), uPhase, uTruth0 );
     if ( fCompl0 ) 
     {
         for ( i = 0; i < nTruthWords; i++ )
             uTruth0[i] = ~uTruth0[i];
     }
 
     // permute the second table
     uPhase = Cut_TruthPhase( pCut, pCut1 );
     Extra_TruthExpand( pCut->nVarsMax, nTruthWords, Cut_CutReadTruth(pCut1), uPhase, uTruth1 );
     if ( fCompl1 ) 
     {
         for ( i = 0; i < nTruthWords; i++ )
             uTruth1[i] = ~uTruth1[i];
     }
 
     // write the resulting table
     pTruthRes = Cut_CutReadTruth(pCut);
 
     if ( pCut->fCompl )
     {
         for ( i = 0; i < nTruthWords; i++ )
             pTruthRes[i] = ~(uTruth0[i] & uTruth1[i]);
     }
     else
     {
         for ( i = 0; i < nTruthWords; i++ )
             pTruthRes[i] = uTruth0[i] & uTruth1[i];
     }
 }

static int Cut_TruthWords ( int nVarsMax )

inlinestatic

Definition at line 125 of file cutInt.h.

125 { return nVarsMax <= 5 ? 1 : (1 << (nVarsMax - 5)); }

Data Structures

Macros

Typedefs

Functions

Macro Definition Documentation

Typedef Documentation

Function Documentation