luke
/
abc
mirror of https://github.com/YosysHQ/abc.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
abc/src/opt/fxu/fxuInt.h

546 lines
24 KiB
C
Raw Blame History

/**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 ///
////////////////////////////////////////////////////////////////////////
Reference in New Issue View Git Blame Copy Permalink