| /**CFile**************************************************************** |
| |
| FileName [fxuInt.h] |
| |
| PackageName [MVSIS 2.0: Multi-valued logic synthesis system.] |
| |
| Synopsis [Internal declarations of fast extract for unate covers.] |
| |
| Author [MVSIS Group] |
| |
| Affiliation [UC Berkeley] |
| |
| Date [Ver. 1.0. Started - February 1, 2003.] |
| |
| Revision [$Id: fxuInt.h,v 1.3 2003/04/10 05:42:44 donald Exp $] |
| |
| ***********************************************************************/ |
| |
| #ifndef ABC__opt__fxu__fxuInt_h |
| #define ABC__opt__fxu__fxuInt_h |
| |
| |
| //////////////////////////////////////////////////////////////////////// |
| /// INCLUDES /// |
| //////////////////////////////////////////////////////////////////////// |
| |
| #include "base/abc/abc.h" |
| |
| ABC_NAMESPACE_HEADER_START |
| |
| |
| //////////////////////////////////////////////////////////////////////// |
| /// PARAMETERS /// |
| //////////////////////////////////////////////////////////////////////// |
| |
| // uncomment this macro to switch to standard memory management |
| //#define USE_SYSTEM_MEMORY_MANAGEMENT |
| |
| //////////////////////////////////////////////////////////////////////// |
| /// STRUCTURE DEFINITIONS /// |
| //////////////////////////////////////////////////////////////////////// |
| |
| /* |
| Here is an informal description of the FX data structure. |
| (1) The sparse matrix is filled with literals, associated with |
| cubes (row) and variables (columns). The matrix contains |
| all the cubes of all the nodes in the network. |
| (2) A cube is associated with |
| (a) its literals in the matrix, |
| (b) the output variable of the node, to which this cube belongs, |
| (3) A variable is associated with |
| (a) its literals in the matrix and |
| (b) the list of cube pairs in the cover, for which it is the output |
| (4) A cube pair is associated with two cubes and contains the counters |
| of literals in the base and in the cubes without the base |
| (5) A double-cube divisor is associated with list of all cube pairs |
| that produce it and its current weight (which is updated automatically |
| each time a new pair is added or an old pair is removed). |
| (6) A single-cube divisor is associated the pair of variables. |
| */ |
| |
| // sparse matrix |
| typedef struct FxuMatrix Fxu_Matrix; // the sparse matrix |
| |
| // sparse matrix contents: cubes (rows), vars (columns), literals (entries) |
| typedef struct FxuCube Fxu_Cube; // one cube in the sparse matrix |
| typedef struct FxuVar Fxu_Var; // one literal in the sparse matrix |
| typedef struct FxuLit Fxu_Lit; // one entry in the sparse matrix |
| |
| // double cube divisors |
| typedef struct FxuPair Fxu_Pair; // the pair of cubes |
| typedef struct FxuDouble Fxu_Double; // the double-cube divisor |
| typedef struct FxuSingle Fxu_Single; // the two-literal single-cube divisor |
| |
| // various lists |
| typedef struct FxuListCube Fxu_ListCube; // the list of cubes |
| typedef struct FxuListVar Fxu_ListVar; // the list of literals |
| typedef struct FxuListLit Fxu_ListLit; // the list of entries |
| typedef struct FxuListPair Fxu_ListPair; // the list of pairs |
| typedef struct FxuListDouble Fxu_ListDouble; // the list of divisors |
| typedef struct FxuListSingle Fxu_ListSingle; // the list of single-cube divisors |
| |
| // various heaps |
| typedef struct FxuHeapDouble Fxu_HeapDouble; // the heap of divisors |
| typedef struct FxuHeapSingle Fxu_HeapSingle; // the heap of variables |
| |
| |
| // various lists |
| |
| // the list of cubes in the sparse matrix |
| struct FxuListCube |
| { |
| Fxu_Cube * pHead; |
| Fxu_Cube * pTail; |
| int nItems; |
| }; |
| |
| // the list of literals in the sparse matrix |
| struct FxuListVar |
| { |
| Fxu_Var * pHead; |
| Fxu_Var * pTail; |
| int nItems; |
| }; |
| |
| // the list of entries in the sparse matrix |
| struct FxuListLit |
| { |
| Fxu_Lit * pHead; |
| Fxu_Lit * pTail; |
| int nItems; |
| }; |
| |
| // the list of cube pair in the sparse matrix |
| struct FxuListPair |
| { |
| Fxu_Pair * pHead; |
| Fxu_Pair * pTail; |
| int nItems; |
| }; |
| |
| // the list of divisors in the sparse matrix |
| struct FxuListDouble |
| { |
| Fxu_Double * pHead; |
| Fxu_Double * pTail; |
| int nItems; |
| }; |
| |
| // the list of divisors in the sparse matrix |
| struct FxuListSingle |
| { |
| Fxu_Single * pHead; |
| Fxu_Single * pTail; |
| int nItems; |
| }; |
| |
| |
| // various heaps |
| |
| // the heap of double cube divisors by weight |
| struct FxuHeapDouble |
| { |
| Fxu_Double ** pTree; |
| int nItems; |
| int nItemsAlloc; |
| int i; |
| }; |
| |
| // the heap of variable by their occurrence in the cubes |
| struct FxuHeapSingle |
| { |
| Fxu_Single ** pTree; |
| int nItems; |
| int nItemsAlloc; |
| int i; |
| }; |
| |
| |
| |
| // sparse matrix |
| struct FxuMatrix // ~ 30 words |
| { |
| // the cubes |
| Fxu_ListCube lCubes; // the double linked list of cubes |
| // the values (binary literals) |
| Fxu_ListVar lVars; // the double linked list of variables |
| Fxu_Var ** ppVars; // the array of variables |
| // the double cube divisors |
| Fxu_ListDouble * pTable; // the hash table of divisors |
| int nTableSize; // the hash table size |
| int nDivs; // the number of divisors in the table |
| int nDivsTotal; // the number of divisors in the table |
| Fxu_HeapDouble * pHeapDouble; // the heap of divisors by weight |
| // the single cube divisors |
| Fxu_ListSingle lSingles; // the linked list of single cube divisors |
| Fxu_HeapSingle * pHeapSingle; // the heap of variables by the number of literals in the matrix |
| int nWeightLimit;// the limit on weight of single cube divisors collected |
| int nSingleTotal;// the total number of single cube divisors |
| // storage for cube pairs |
| Fxu_Pair *** pppPairs; |
| Fxu_Pair ** ppPairs; |
| // temporary storage for cubes |
| Fxu_Cube * pOrderCubes; |
| Fxu_Cube ** ppTailCubes; |
| // temporary storage for variables |
| Fxu_Var * pOrderVars; |
| Fxu_Var ** ppTailVars; |
| // temporary storage for pairs |
| Vec_Ptr_t * vPairs; |
| // statistics |
| int nEntries; // the total number of entries in the sparse matrix |
| int nDivs1; // the single cube divisors taken |
| int nDivs2; // the double cube divisors taken |
| int nDivs3; // the double cube divisors with complement |
| // memory manager |
| Extra_MmFixed_t * pMemMan; // the memory manager for all small sized entries |
| }; |
| |
| // the cube in the sparse matrix |
| struct FxuCube // 9 words |
| { |
| int iCube; // the number of this cube in the cover |
| Fxu_Cube * pFirst; // the pointer to the first cube of this cover |
| Fxu_Var * pVar; // the variable representing the output of the cover |
| Fxu_ListLit lLits; // the row in the table |
| Fxu_Cube * pPrev; // the previous cube |
| Fxu_Cube * pNext; // the next cube |
| Fxu_Cube * pOrder; // the specialized linked list of cubes |
| }; |
| |
| // the variable in the sparse matrix |
| struct FxuVar // 10 words |
| { |
| int iVar; // the number of this variable |
| int nCubes; // the number of cubes assoc with this var |
| Fxu_Cube * pFirst; // the first cube assoc with this var |
| Fxu_Pair *** ppPairs; // the pairs of cubes assoc with this var |
| Fxu_ListLit lLits; // the column in the table |
| Fxu_Var * pPrev; // the previous variable |
| Fxu_Var * pNext; // the next variable |
| Fxu_Var * pOrder; // the specialized linked list of variables |
| }; |
| |
| // the literal entry in the sparse matrix |
| struct FxuLit // 8 words |
| { |
| int iVar; // the number of this variable |
| int iCube; // the number of this cube |
| Fxu_Cube * pCube; // the cube of this literal |
| Fxu_Var * pVar; // the variable of this literal |
| Fxu_Lit * pHPrev; // prev lit in the cube |
| Fxu_Lit * pHNext; // next lit in the cube |
| Fxu_Lit * pVPrev; // prev lit of the var |
| Fxu_Lit * pVNext; // next lit of the var |
| }; |
| |
| // the cube pair |
| struct FxuPair // 10 words |
| { |
| int nLits1; // the number of literals in the two cubes |
| int nLits2; // the number of literals in the two cubes |
| int nBase; // the number of literals in the base |
| Fxu_Double * pDiv; // the divisor of this pair |
| Fxu_Cube * pCube1; // the first cube of the pair |
| Fxu_Cube * pCube2; // the second cube of the pair |
| int iCube1; // the first cube of the pair |
| int iCube2; // the second cube of the pair |
| Fxu_Pair * pDPrev; // the previous pair in the divisor |
| Fxu_Pair * pDNext; // the next pair in the divisor |
| }; |
| |
| // the double cube divisor |
| struct FxuDouble // 10 words |
| { |
| int Num; // the unique number of this divisor |
| int HNum; // the heap number of this divisor |
| int Weight; // the weight of this divisor |
| unsigned Key; // the hash key of this divisor |
| Fxu_ListPair lPairs; // the pairs of cubes, which produce this divisor |
| Fxu_Double * pPrev; // the previous divisor in the table |
| Fxu_Double * pNext; // the next divisor in the table |
| Fxu_Double * pOrder; // the specialized linked list of divisors |
| }; |
| |
| // the single cube divisor |
| struct FxuSingle // 7 words |
| { |
| int Num; // the unique number of this divisor |
| int HNum; // the heap number of this divisor |
| int Weight; // the weight of this divisor |
| Fxu_Var * pVar1; // the first variable of the single-cube divisor |
| Fxu_Var * pVar2; // the second variable of the single-cube divisor |
| Fxu_Single * pPrev; // the previous divisor in the list |
| Fxu_Single * pNext; // the next divisor in the list |
| }; |
| |
| //////////////////////////////////////////////////////////////////////// |
| /// MACRO DEFINITIONS /// |
| //////////////////////////////////////////////////////////////////////// |
| |
| // minimum/maximum |
| #define Fxu_Min( a, b ) ( ((a)<(b))? (a):(b) ) |
| #define Fxu_Max( a, b ) ( ((a)>(b))? (a):(b) ) |
| |
| // selection of the minimum/maximum cube in the pair |
| #define Fxu_PairMinCube( pPair ) (((pPair)->iCube1 < (pPair)->iCube2)? (pPair)->pCube1: (pPair)->pCube2) |
| #define Fxu_PairMaxCube( pPair ) (((pPair)->iCube1 > (pPair)->iCube2)? (pPair)->pCube1: (pPair)->pCube2) |
| #define Fxu_PairMinCubeInt( pPair ) (((pPair)->iCube1 < (pPair)->iCube2)? (pPair)->iCube1: (pPair)->iCube2) |
| #define Fxu_PairMaxCubeInt( pPair ) (((pPair)->iCube1 > (pPair)->iCube2)? (pPair)->iCube1: (pPair)->iCube2) |
| |
| // iterators |
| |
| #define Fxu_MatrixForEachCube( Matrix, Cube )\ |
| for ( Cube = (Matrix)->lCubes.pHead;\ |
| Cube;\ |
| Cube = Cube->pNext ) |
| #define Fxu_MatrixForEachCubeSafe( Matrix, Cube, Cube2 )\ |
| for ( Cube = (Matrix)->lCubes.pHead, Cube2 = (Cube? Cube->pNext: NULL);\ |
| Cube;\ |
| Cube = Cube2, Cube2 = (Cube? Cube->pNext: NULL) ) |
| |
| #define Fxu_MatrixForEachVariable( Matrix, Var )\ |
| for ( Var = (Matrix)->lVars.pHead;\ |
| Var;\ |
| Var = Var->pNext ) |
| #define Fxu_MatrixForEachVariableSafe( Matrix, Var, Var2 )\ |
| for ( Var = (Matrix)->lVars.pHead, Var2 = (Var? Var->pNext: NULL);\ |
| Var;\ |
| Var = Var2, Var2 = (Var? Var->pNext: NULL) ) |
| |
| #define Fxu_MatrixForEachSingle( Matrix, Single )\ |
| for ( Single = (Matrix)->lSingles.pHead;\ |
| Single;\ |
| Single = Single->pNext ) |
| #define Fxu_MatrixForEachSingleSafe( Matrix, Single, Single2 )\ |
| for ( Single = (Matrix)->lSingles.pHead, Single2 = (Single? Single->pNext: NULL);\ |
| Single;\ |
| Single = Single2, Single2 = (Single? Single->pNext: NULL) ) |
| |
| #define Fxu_TableForEachDouble( Matrix, Key, Div )\ |
| for ( Div = (Matrix)->pTable[Key].pHead;\ |
| Div;\ |
| Div = Div->pNext ) |
| #define Fxu_TableForEachDoubleSafe( Matrix, Key, Div, Div2 )\ |
| for ( Div = (Matrix)->pTable[Key].pHead, Div2 = (Div? Div->pNext: NULL);\ |
| Div;\ |
| Div = Div2, Div2 = (Div? Div->pNext: NULL) ) |
| |
| #define Fxu_MatrixForEachDouble( Matrix, Div, Index )\ |
| for ( Index = 0; Index < (Matrix)->nTableSize; Index++ )\ |
| Fxu_TableForEachDouble( Matrix, Index, Div ) |
| #define Fxu_MatrixForEachDoubleSafe( Matrix, Div, Div2, Index )\ |
| for ( Index = 0; Index < (Matrix)->nTableSize; Index++ )\ |
| Fxu_TableForEachDoubleSafe( Matrix, Index, Div, Div2 ) |
| |
| |
| #define Fxu_CubeForEachLiteral( Cube, Lit )\ |
| for ( Lit = (Cube)->lLits.pHead;\ |
| Lit;\ |
| Lit = Lit->pHNext ) |
| #define Fxu_CubeForEachLiteralSafe( Cube, Lit, Lit2 )\ |
| for ( Lit = (Cube)->lLits.pHead, Lit2 = (Lit? Lit->pHNext: NULL);\ |
| Lit;\ |
| Lit = Lit2, Lit2 = (Lit? Lit->pHNext: NULL) ) |
| |
| #define Fxu_VarForEachLiteral( Var, Lit )\ |
| for ( Lit = (Var)->lLits.pHead;\ |
| Lit;\ |
| Lit = Lit->pVNext ) |
| |
| #define Fxu_CubeForEachDivisor( Cube, Div )\ |
| for ( Div = (Cube)->lDivs.pHead;\ |
| Div;\ |
| Div = Div->pCNext ) |
| |
| #define Fxu_DoubleForEachPair( Div, Pair )\ |
| for ( Pair = (Div)->lPairs.pHead;\ |
| Pair;\ |
| Pair = Pair->pDNext ) |
| #define Fxu_DoubleForEachPairSafe( Div, Pair, Pair2 )\ |
| for ( Pair = (Div)->lPairs.pHead, Pair2 = (Pair? Pair->pDNext: NULL);\ |
| Pair;\ |
| Pair = Pair2, Pair2 = (Pair? Pair->pDNext: NULL) ) |
| |
| |
| // iterator through the cube pairs belonging to the given cube |
| #define Fxu_CubeForEachPair( pCube, pPair, i )\ |
| for ( i = 0;\ |
| i < pCube->pVar->nCubes && (((pPair) = (pCube)->pVar->ppPairs[(pCube)->iCube][i]), 1);\ |
| i++ )\ |
| if ( pPair == NULL ) {} else |
| |
| // iterator through all the items in the heap |
| #define Fxu_HeapDoubleForEachItem( Heap, Div )\ |
| for ( Heap->i = 1;\ |
| Heap->i <= Heap->nItems && (Div = Heap->pTree[Heap->i]);\ |
| Heap->i++ ) |
| #define Fxu_HeapSingleForEachItem( Heap, Single )\ |
| for ( Heap->i = 1;\ |
| Heap->i <= Heap->nItems && (Single = Heap->pTree[Heap->i]);\ |
| Heap->i++ ) |
| |
| // starting the rings |
| #define Fxu_MatrixRingCubesStart( Matrix ) (((Matrix)->ppTailCubes = &((Matrix)->pOrderCubes)), ((Matrix)->pOrderCubes = NULL)) |
| #define Fxu_MatrixRingVarsStart( Matrix ) (((Matrix)->ppTailVars = &((Matrix)->pOrderVars)), ((Matrix)->pOrderVars = NULL)) |
| // stopping the rings |
| #define Fxu_MatrixRingCubesStop( Matrix ) |
| #define Fxu_MatrixRingVarsStop( Matrix ) |
| // resetting the rings |
| #define Fxu_MatrixRingCubesReset( Matrix ) (((Matrix)->pOrderCubes = NULL), ((Matrix)->ppTailCubes = NULL)) |
| #define Fxu_MatrixRingVarsReset( Matrix ) (((Matrix)->pOrderVars = NULL), ((Matrix)->ppTailVars = NULL)) |
| // adding to the rings |
| #define Fxu_MatrixRingCubesAdd( Matrix, Cube) ((*((Matrix)->ppTailCubes) = Cube), ((Matrix)->ppTailCubes = &(Cube)->pOrder), ((Cube)->pOrder = (Fxu_Cube *)1)) |
| #define Fxu_MatrixRingVarsAdd( Matrix, Var ) ((*((Matrix)->ppTailVars ) = Var ), ((Matrix)->ppTailVars = &(Var)->pOrder ), ((Var)->pOrder = (Fxu_Var *)1)) |
| // iterating through the rings |
| #define Fxu_MatrixForEachCubeInRing( Matrix, Cube )\ |
| if ( (Matrix)->pOrderCubes )\ |
| for ( Cube = (Matrix)->pOrderCubes;\ |
| Cube != (Fxu_Cube *)1;\ |
| Cube = Cube->pOrder ) |
| #define Fxu_MatrixForEachCubeInRingSafe( Matrix, Cube, Cube2 )\ |
| if ( (Matrix)->pOrderCubes )\ |
| for ( Cube = (Matrix)->pOrderCubes, Cube2 = ((Cube != (Fxu_Cube *)1)? Cube->pOrder: (Fxu_Cube *)1);\ |
| Cube != (Fxu_Cube *)1;\ |
| Cube = Cube2, Cube2 = ((Cube != (Fxu_Cube *)1)? Cube->pOrder: (Fxu_Cube *)1) ) |
| #define Fxu_MatrixForEachVarInRing( Matrix, Var )\ |
| if ( (Matrix)->pOrderVars )\ |
| for ( Var = (Matrix)->pOrderVars;\ |
| Var != (Fxu_Var *)1;\ |
| Var = Var->pOrder ) |
| #define Fxu_MatrixForEachVarInRingSafe( Matrix, Var, Var2 )\ |
| if ( (Matrix)->pOrderVars )\ |
| for ( Var = (Matrix)->pOrderVars, Var2 = ((Var != (Fxu_Var *)1)? Var->pOrder: (Fxu_Var *)1);\ |
| Var != (Fxu_Var *)1;\ |
| Var = Var2, Var2 = ((Var != (Fxu_Var *)1)? Var->pOrder: (Fxu_Var *)1) ) |
| // the procedures are related to the above macros |
| extern void Fxu_MatrixRingCubesUnmark( Fxu_Matrix * p ); |
| extern void Fxu_MatrixRingVarsUnmark( Fxu_Matrix * p ); |
| |
| |
| // macros working with memory |
| // MEM_ALLOC: allocate the given number (Size) of items of type (Type) |
| // MEM_FREE: deallocate the pointer (Pointer) to the given number (Size) of items of type (Type) |
| #ifdef USE_SYSTEM_MEMORY_MANAGEMENT |
| #define MEM_ALLOC_FXU( Manager, Type, Size ) ((Type *)ABC_ALLOC( char, (Size) * sizeof(Type) )) |
| #define MEM_FREE_FXU( Manager, Type, Size, Pointer ) if ( Pointer ) { ABC_FREE(Pointer); Pointer = NULL; } |
| #else |
| #define MEM_ALLOC_FXU( Manager, Type, Size )\ |
| ((Type *)Fxu_MemFetch( Manager, (Size) * sizeof(Type) )) |
| #define MEM_FREE_FXU( Manager, Type, Size, Pointer )\ |
| if ( Pointer ) { Fxu_MemRecycle( Manager, (char *)(Pointer), (Size) * sizeof(Type) ); Pointer = NULL; } |
| #endif |
| |
| //////////////////////////////////////////////////////////////////////// |
| /// FUNCTION DEFINITIONS /// |
| //////////////////////////////////////////////////////////////////////// |
| |
| /*===== fxu.c ====================================================*/ |
| extern char * Fxu_MemFetch( Fxu_Matrix * p, int nBytes ); |
| extern void Fxu_MemRecycle( Fxu_Matrix * p, char * pItem, int nBytes ); |
| /*===== fxuCreate.c ====================================================*/ |
| /*===== fxuReduce.c ====================================================*/ |
| /*===== fxuPrint.c ====================================================*/ |
| extern void Fxu_MatrixPrint( FILE * pFile, Fxu_Matrix * p ); |
| extern void Fxu_MatrixPrintDivisorProfile( FILE * pFile, Fxu_Matrix * p ); |
| /*===== fxuSelect.c ====================================================*/ |
| extern int Fxu_Select( Fxu_Matrix * p, Fxu_Single ** ppSingle, Fxu_Double ** ppDouble ); |
| extern int Fxu_SelectSCD( Fxu_Matrix * p, int Weight, Fxu_Var ** ppVar1, Fxu_Var ** ppVar2 ); |
| /*===== fxuUpdate.c ====================================================*/ |
| extern void Fxu_Update( Fxu_Matrix * p, Fxu_Single * pSingle, Fxu_Double * pDouble ); |
| extern void Fxu_UpdateDouble( Fxu_Matrix * p ); |
| extern void Fxu_UpdateSingle( Fxu_Matrix * p ); |
| /*===== fxuPair.c ====================================================*/ |
| extern void Fxu_PairCanonicize( Fxu_Cube ** ppCube1, Fxu_Cube ** ppCube2 ); |
| extern unsigned Fxu_PairHashKeyArray( Fxu_Matrix * p, int piVarsC1[], int piVarsC2[], int nVarsC1, int nVarsC2 ); |
| extern unsigned Fxu_PairHashKey( Fxu_Matrix * p, Fxu_Cube * pCube1, Fxu_Cube * pCube2, int * pnBase, int * pnLits1, int * pnLits2 ); |
| extern unsigned Fxu_PairHashKeyMv( Fxu_Matrix * p, Fxu_Cube * pCube1, Fxu_Cube * pCube2, int * pnBase, int * pnLits1, int * pnLits2 ); |
| extern int Fxu_PairCompare( Fxu_Pair * pPair1, Fxu_Pair * pPair2 ); |
| extern void Fxu_PairAllocStorage( Fxu_Var * pVar, int nCubes ); |
| extern void Fxu_PairFreeStorage( Fxu_Var * pVar ); |
| extern void Fxu_PairClearStorage( Fxu_Cube * pCube ); |
| extern Fxu_Pair * Fxu_PairAlloc( Fxu_Matrix * p, Fxu_Cube * pCube1, Fxu_Cube * pCube2 ); |
| extern void Fxu_PairAdd( Fxu_Pair * pPair ); |
| /*===== fxuSingle.c ====================================================*/ |
| extern void Fxu_MatrixComputeSingles( Fxu_Matrix * p, int fUse0, int nSingleMax ); |
| extern void Fxu_MatrixComputeSinglesOne( Fxu_Matrix * p, Fxu_Var * pVar ); |
| extern int Fxu_SingleCountCoincidence( Fxu_Matrix * p, Fxu_Var * pVar1, Fxu_Var * pVar2 ); |
| /*===== fxuMatrix.c ====================================================*/ |
| // matrix |
| extern Fxu_Matrix * Fxu_MatrixAllocate(); |
| extern void Fxu_MatrixDelete( Fxu_Matrix * p ); |
| // double-cube divisor |
| extern void Fxu_MatrixAddDivisor( Fxu_Matrix * p, Fxu_Cube * pCube1, Fxu_Cube * pCube2 ); |
| extern void Fxu_MatrixDelDivisor( Fxu_Matrix * p, Fxu_Double * pDiv ); |
| // single-cube divisor |
| extern void Fxu_MatrixAddSingle( Fxu_Matrix * p, Fxu_Var * pVar1, Fxu_Var * pVar2, int Weight ); |
| // variable |
| extern Fxu_Var * Fxu_MatrixAddVar( Fxu_Matrix * p ); |
| // cube |
| extern Fxu_Cube * Fxu_MatrixAddCube( Fxu_Matrix * p, Fxu_Var * pVar, int iCube ); |
| // literal |
| extern void Fxu_MatrixAddLiteral( Fxu_Matrix * p, Fxu_Cube * pCube, Fxu_Var * pVar ); |
| extern void Fxu_MatrixDelLiteral( Fxu_Matrix * p, Fxu_Lit * pLit ); |
| /*===== fxuList.c ====================================================*/ |
| // matrix -> variable |
| extern void Fxu_ListMatrixAddVariable( Fxu_Matrix * p, Fxu_Var * pVar ); |
| extern void Fxu_ListMatrixDelVariable( Fxu_Matrix * p, Fxu_Var * pVar ); |
| // matrix -> cube |
| extern void Fxu_ListMatrixAddCube( Fxu_Matrix * p, Fxu_Cube * pCube ); |
| extern void Fxu_ListMatrixDelCube( Fxu_Matrix * p, Fxu_Cube * pCube ); |
| // matrix -> single |
| extern void Fxu_ListMatrixAddSingle( Fxu_Matrix * p, Fxu_Single * pSingle ); |
| extern void Fxu_ListMatrixDelSingle( Fxu_Matrix * p, Fxu_Single * pSingle ); |
| // table -> divisor |
| extern void Fxu_ListTableAddDivisor( Fxu_Matrix * p, Fxu_Double * pDiv ); |
| extern void Fxu_ListTableDelDivisor( Fxu_Matrix * p, Fxu_Double * pDiv ); |
| // cube -> literal |
| extern void Fxu_ListCubeAddLiteral( Fxu_Cube * pCube, Fxu_Lit * pLit ); |
| extern void Fxu_ListCubeDelLiteral( Fxu_Cube * pCube, Fxu_Lit * pLit ); |
| // var -> literal |
| extern void Fxu_ListVarAddLiteral( Fxu_Var * pVar, Fxu_Lit * pLit ); |
| extern void Fxu_ListVarDelLiteral( Fxu_Var * pVar, Fxu_Lit * pLit ); |
| // divisor -> pair |
| extern void Fxu_ListDoubleAddPairLast( Fxu_Double * pDiv, Fxu_Pair * pLink ); |
| extern void Fxu_ListDoubleAddPairFirst( Fxu_Double * pDiv, Fxu_Pair * pLink ); |
| extern void Fxu_ListDoubleAddPairMiddle( Fxu_Double * pDiv, Fxu_Pair * pSpot, Fxu_Pair * pLink ); |
| extern void Fxu_ListDoubleDelPair( Fxu_Double * pDiv, Fxu_Pair * pPair ); |
| /*===== fxuHeapDouble.c ====================================================*/ |
| extern Fxu_HeapDouble * Fxu_HeapDoubleStart(); |
| extern void Fxu_HeapDoubleStop( Fxu_HeapDouble * p ); |
| extern void Fxu_HeapDoublePrint( FILE * pFile, Fxu_HeapDouble * p ); |
| extern void Fxu_HeapDoubleCheck( Fxu_HeapDouble * p ); |
| extern void Fxu_HeapDoubleCheckOne( Fxu_HeapDouble * p, Fxu_Double * pDiv ); |
| |
| extern void Fxu_HeapDoubleInsert( Fxu_HeapDouble * p, Fxu_Double * pDiv ); |
| extern void Fxu_HeapDoubleUpdate( Fxu_HeapDouble * p, Fxu_Double * pDiv ); |
| extern void Fxu_HeapDoubleDelete( Fxu_HeapDouble * p, Fxu_Double * pDiv ); |
| extern int Fxu_HeapDoubleReadMaxWeight( Fxu_HeapDouble * p ); |
| extern Fxu_Double * Fxu_HeapDoubleReadMax( Fxu_HeapDouble * p ); |
| extern Fxu_Double * Fxu_HeapDoubleGetMax( Fxu_HeapDouble * p ); |
| /*===== fxuHeapSingle.c ====================================================*/ |
| extern Fxu_HeapSingle * Fxu_HeapSingleStart(); |
| extern void Fxu_HeapSingleStop( Fxu_HeapSingle * p ); |
| extern void Fxu_HeapSinglePrint( FILE * pFile, Fxu_HeapSingle * p ); |
| extern void Fxu_HeapSingleCheck( Fxu_HeapSingle * p ); |
| extern void Fxu_HeapSingleCheckOne( Fxu_HeapSingle * p, Fxu_Single * pSingle ); |
| |
| extern void Fxu_HeapSingleInsert( Fxu_HeapSingle * p, Fxu_Single * pSingle ); |
| extern void Fxu_HeapSingleUpdate( Fxu_HeapSingle * p, Fxu_Single * pSingle ); |
| extern void Fxu_HeapSingleDelete( Fxu_HeapSingle * p, Fxu_Single * pSingle ); |
| extern int Fxu_HeapSingleReadMaxWeight( Fxu_HeapSingle * p ); |
| extern Fxu_Single * Fxu_HeapSingleReadMax( Fxu_HeapSingle * p ); |
| extern Fxu_Single * Fxu_HeapSingleGetMax( Fxu_HeapSingle * p ); |
| |
| |
| |
| ABC_NAMESPACE_HEADER_END |
| |
| #endif |
| |
| //////////////////////////////////////////////////////////////////////// |
| /// END OF FILE /// |
| //////////////////////////////////////////////////////////////////////// |
| |
