ruby_abc 0.0.3 → 0.1.0

data/ext/abc/src/bdd/mtr/mtrInt.h

@@ -1,94 +0,0 @@
-/**CHeaderFile*****************************************************************
-
-  FileName    [mtrInt.h]
-
-  PackageName [mtr]
-
-  Synopsis    [Internal data structures of the mtr package]
-
-  Description [In this package all definitions are external.]
-
-  SeeAlso     []
-
-  Author      [Fabio Somenzi]
-
-  Copyright   [Copyright (c) 1995-2004, Regents of the University of Colorado
-
-  All rights reserved.
-
-  Redistribution and use in source and binary forms, with or without
-  modification, are permitted provided that the following conditions
-  are met:
-
-  Redistributions of source code must retain the above copyright
-  notice, this list of conditions and the following disclaimer.
-
-  Redistributions in binary form must reproduce the above copyright
-  notice, this list of conditions and the following disclaimer in the
-  documentation and/or other materials provided with the distribution.
-
-  Neither the name of the University of Colorado nor the names of its
-  contributors may be used to endorse or promote products derived from
-  this software without specific prior written permission.
-
-  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
-  FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
-  COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
-  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
-  BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
-  CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
-  LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
-  ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
-  POSSIBILITY OF SUCH DAMAGE.]
-
-  Revision    [$Id: mtrInt.h,v 1.2 2004/08/13 18:15:12 fabio Exp $]
-
-******************************************************************************/
-
-#ifndef ABC__bdd__mtr__mtrInt_h
-#define ABC__bdd__mtr__mtrInt_h
-
-#include "mtr.h"
-
-/*---------------------------------------------------------------------------*/
-/* Nested includes                                                           */
-/*---------------------------------------------------------------------------*/
-
-ABC_NAMESPACE_HEADER_START
-
-/*---------------------------------------------------------------------------*/
-/* Constant declarations                                                     */
-/*---------------------------------------------------------------------------*/
-
-/*---------------------------------------------------------------------------*/
-/* Stucture declarations                                                     */
-/*---------------------------------------------------------------------------*/
-
-
-/*---------------------------------------------------------------------------*/
-/* Type declarations                                                         */
-/*---------------------------------------------------------------------------*/
-
-/*---------------------------------------------------------------------------*/
-/* Variable declarations                                                     */
-/*---------------------------------------------------------------------------*/
-
-
-/*---------------------------------------------------------------------------*/
-/* Macro declarations                                                        */
-/*---------------------------------------------------------------------------*/
-
-/**AutomaticStart*************************************************************/
-
-/*---------------------------------------------------------------------------*/
-/* Function prototypes                                                       */
-/*---------------------------------------------------------------------------*/
-
-ABC_NAMESPACE_HEADER_END
-
-/**AutomaticEnd***************************************************************/
-
-#endif /* _MTRINT */

data/ext/abc/src/bdd/reo/module.make

@@ -1,8 +0,0 @@
-SRC +=	src/bdd/reo/reoApi.c \
-	src/bdd/reo/reoCore.c \
-	src/bdd/reo/reoProfile.c \
-	src/bdd/reo/reoShuffle.c \
-	src/bdd/reo/reoSift.c \
-	src/bdd/reo/reoSwap.c \
-	src/bdd/reo/reoTransfer.c \
-	src/bdd/reo/reoUnits.c

data/ext/abc/src/bdd/reo/reo.h

@@ -1,234 +0,0 @@
-/**CFile****************************************************************
-
-  FileName    [reo.h]
-
-  PackageName [REO: A specialized DD reordering engine.]
-
-  Synopsis    [External and internal declarations.]
-
-  Author      [Alan Mishchenko]
-  
-  Affiliation [UC Berkeley]
-
-  Date        [Ver. 1.0. Started - October 15, 2002.]
-
-  Revision    [$Id: reo.h,v 1.0 2002/15/10 03:00:00 alanmi Exp $]
-
-***********************************************************************/
-
-#ifndef ABC__bdd__reo__reo_h
-#define ABC__bdd__reo__reo_h
-
-
-#include <stdio.h>
-#include <stdlib.h>
-#include "bdd/extrab/extraBdd.h"
-
-////////////////////////////////////////////////////////////////////////
-///                     MACRO DEFINITIONS                            ///
-////////////////////////////////////////////////////////////////////////
-
-
-
-ABC_NAMESPACE_HEADER_START
-
-
-// reordering parameters
-#define REO_REORDER_LIMIT      1.15  // determines the quality/runtime trade-off
-#define REO_QUAL_PAR              3  // the quality [1 = simple lower bound, 2 = strict, larger = heuristic]
-// internal parameters
-#define REO_CONST_LEVEL       30000  // the number of the constant level
-#define REO_TOPREF_UNDEF      30000  // the undefined top reference
-#define REO_CHUNK_SIZE         5000  // the number of units allocated at one time
-#define REO_COST_EPSILON  0.0000001  // difference in cost large enough so that it counted as an error
-#define REO_HIGH_VALUE     10000000  // a large value used to initialize some variables
-// interface parameters
-#define REO_ENABLE                1  // the value of the enable flag
-#define REO_DISABLE               0  // the value of the disable flag
-
-// the types of minimization currently supported
-typedef enum {
-	REO_MINIMIZE_NODES,
-	REO_MINIMIZE_WIDTH,   // may not work for BDDs with complemented edges
-	REO_MINIMIZE_APL
-} reo_min_type;
-
-////////////////////////////////////////////////////////////////////////
-///                      DATA STRUCTURES                             ///
-////////////////////////////////////////////////////////////////////////
-
-typedef struct _reo_unit     reo_unit;    // the unit representing one DD node during reordering
-typedef struct _reo_plane    reo_plane;   // the set of nodes on one level
-typedef struct _reo_hash     reo_hash;    // the entry in the hash table
-typedef struct _reo_man      reo_man;     // the reordering manager
-typedef struct _reo_test     reo_test;    // 
-
-struct _reo_unit
-{
-	short       lev;             // the level of this node at the beginning
-	short       TopRef;          // the top level from which this node is refed (used to update BDD width)
-	short       TopRefNew;       // the new top level from which this node is refed (used to update BDD width)
-	short       n;               // the number of incoming edges (similar to ref count in the BDD)
-	int         Sign;            // the signature
-
-	reo_unit *  pE;              // the pointer to the "else" branch
-	reo_unit *  pT;              // the pointer to the "then" branch
-	reo_unit *  Next;            // the link to the next one in the list
-	double      Weight;          // the probability of traversing this node
-};
-
-struct _reo_plane
-{
-	int         fSifted;         // to mark the sifted variables
-	int         statsNodes;      // the number of nodes in the current level
-	int         statsWidth;      // the width on the current level
-	double      statsApl;        // the sum of node probabilities on this level
-	double      statsCost;       // the current cost is stored here
-	double      statsCostAbove;  // the current cost is stored here
-	double      statsCostBelow;  // the current cost is stored here
-
-	reo_unit *  pHead;           // the pointer to the beginning of the unit list
-};
-
-struct _reo_hash
-{
-	int         Sign;            // signature of the current cache operation
-	reo_unit *  Arg1;            // the first argument
-	reo_unit *  Arg2;            // the second argument
-	reo_unit *  Arg3;            // the third argument
-};
-
-struct _reo_man
-{
-	// these paramaters can be set by the API functions
-	int         fMinWidth;       // the flag to enable reordering for minimum width
-	int         fMinApl;         // the flag to enable reordering for minimum APL
-	int         fVerbose;        // the verbosity level
-	int         fVerify;         // the flag toggling verification
-	int         fRemapUp;        // the flag to enable remapping   
-	int         nIters;          // the number of interations of sifting to perform
-
-	// parameters given by the user when reordering is called
-	DdManager * dd;              // the CUDD BDD manager
-	int *       pOrder;          // the resulting variable order will be returned here
-
-	// derived parameters
-	int         fThisIsAdd;      // this flag is one if the function is the ADD 
-	int *       pSupp;           // the support of the given function
-	int         nSuppAlloc;      // the max allowed number of support variables
-	int         nSupp;           // the number of support variables
-	int *       pOrderInt;       // the array storing the internal variable permutation
-	double *    pVarCosts;       // other arrays
-	int *       pLevelOrder;     // other arrays
-	reo_unit ** pWidthCofs;      // temporary storage for cofactors used during reordering for width
-
-	// parameters related to cost
-	int         nNodesBeg;
-	int         nNodesCur;
-	int         nNodesEnd;
-	int         nWidthCur;
-	int         nWidthBeg;
-	int         nWidthEnd;
-	double      nAplCur;
-	double      nAplBeg;
-	double      nAplEnd;
-
-	// mapping of the function into planes and back
-	int *       pMapToPlanes;    // the mapping of var indexes into plane levels
-	int *       pMapToDdVarsOrig;// the mapping of plane levels into the original indexes
-	int *       pMapToDdVarsFinal;// the mapping of plane levels into the final indexes
-
-	// the planes table
-	reo_plane * pPlanes;
-	int         nPlanes;
-	reo_unit ** pTops;
-	int         nTops;
-	int         nTopsAlloc;
-
-	// the hash table
-	reo_hash *  HTable;           // the table itself
-	int         nTableSize;       // the size of the hash table
-	int         Signature;        // the signature counter
-
-	// the referenced node list
-	int         nNodesMaxAlloc;   // this parameters determins how much memory is allocated
-	DdNode **   pRefNodes;
-	int         nRefNodes;
-	int         nRefNodesAlloc;
-
-	// unit memory management
-	reo_unit *  pUnitFreeList;
-	reo_unit ** pMemChunks;
-	int         nMemChunks;
-	int         nMemChunksAlloc;
-	int         nUnitsUsed;
-
-	// statistic variables
-	int         HashSuccess;
-	int         HashFailure;
-	int         nSwaps;            // the number of swaps
-	int         nNISwaps;          // the number of swaps without interaction
-};
-
-// used to manipulate units
-#define Unit_Regular(u)     ((reo_unit *)((ABC_PTRUINT_T)(u) & ~01))
-#define Unit_Not(u)         ((reo_unit *)((ABC_PTRUINT_T)(u) ^ 01))
-#define Unit_NotCond(u,c)   ((reo_unit *)((ABC_PTRUINT_T)(u) ^ (c)))
-#define Unit_IsConstant(u)  ((int)((u)->lev == REO_CONST_LEVEL))
-
-////////////////////////////////////////////////////////////////////////
-///                   FUNCTION DECLARATIONS                          ///
-////////////////////////////////////////////////////////////////////////
-
-// ======================= reoApi.c ========================================
-extern reo_man *  Extra_ReorderInit( int nDdVarsMax, int nNodesMax );
-extern void       Extra_ReorderQuit( reo_man * p );
-extern void       Extra_ReorderSetMinimizationType( reo_man * p, reo_min_type fMinType );
-extern void       Extra_ReorderSetRemapping( reo_man * p, int fRemapUp );
-extern void       Extra_ReorderSetIterations( reo_man * p, int nIters );
-extern void       Extra_ReorderSetVerbosity( reo_man * p, int fVerbose );
-extern void       Extra_ReorderSetVerification( reo_man * p, int fVerify );
-extern DdNode *   Extra_Reorder( reo_man * p, DdManager * dd, DdNode * Func, int * pOrder );
-extern void       Extra_ReorderArray( reo_man * p, DdManager * dd, DdNode * Funcs[], DdNode * FuncsRes[], int nFuncs, int * pOrder );
-// ======================= reoCore.c =======================================
-extern void       reoReorderArray( reo_man * p, DdManager * dd, DdNode * Funcs[], DdNode * FuncsRes[], int nFuncs, int * pOrder );
-extern void       reoResizeStructures( reo_man * p, int nDdVarsMax, int nNodesMax, int nFuncs );
-// ======================= reoProfile.c ======================================
-extern void       reoProfileNodesStart( reo_man * p );
-extern void       reoProfileAplStart( reo_man * p );
-extern void       reoProfileWidthStart( reo_man * p );
-extern void       reoProfileWidthStart2( reo_man * p );
-extern void       reoProfileAplPrint( reo_man * p );
-extern void       reoProfileNodesPrint( reo_man * p );
-extern void       reoProfileWidthPrint( reo_man * p );
-extern void       reoProfileWidthVerifyLevel( reo_plane * pPlane, int Level );
-// ======================= reoSift.c =======================================
-extern void       reoReorderSift( reo_man * p );
-// ======================= reoSwap.c =======================================
-extern double     reoReorderSwapAdjacentVars( reo_man * p, int Level, int fMovingUp );
-// ======================= reoTransfer.c ===================================
-extern reo_unit * reoTransferNodesToUnits_rec( reo_man * p, DdNode * F );
-extern DdNode *   reoTransferUnitsToNodes_rec( reo_man * p, reo_unit * pUnit );
-// ======================= reoUnits.c ======================================
-extern reo_unit * reoUnitsGetNextUnit(reo_man * p );
-extern void       reoUnitsRecycleUnit( reo_man * p, reo_unit * pUnit );
-extern void       reoUnitsRecycleUnitList( reo_man * p, reo_plane * pPlane );
-extern void       reoUnitsAddUnitToPlane( reo_plane * pPlane, reo_unit * pUnit );
-extern void       reoUnitsStopDispenser( reo_man * p );
-// ======================= reoTest.c =======================================
-extern void       Extra_ReorderTest( DdManager * dd, DdNode * Func );
-extern DdNode *   Extra_ReorderCudd( DdManager * dd, DdNode * aFunc, int pPermuteReo[] );
-extern int        Extra_bddReorderTest( DdManager * dd, DdNode * bF ); 
-extern int        Extra_addReorderTest( DdManager * dd, DdNode * aF ); 
-
-
-
-ABC_NAMESPACE_HEADER_END
-
-
-
-#endif
-
-////////////////////////////////////////////////////////////////////////
-///                         END OF FILE                              ///
-////////////////////////////////////////////////////////////////////////

data/ext/abc/src/bdd/reo/reoApi.c

@@ -1,294 +0,0 @@
-/**CFile****************************************************************
-
-  FileName    [reoApi.c]
-
-  PackageName [REO: A specialized DD reordering engine.]
-
-  Synopsis    [Implementation of API functions.]
-
-  Author      [Alan Mishchenko]
-  
-  Affiliation [UC Berkeley]
-
-  Date        [Ver. 1.0. Started - October 15, 2002.]
-
-  Revision    [$Id: reoApi.c,v 1.0 2002/15/10 03:00:00 alanmi Exp $]
-
-***********************************************************************/
-
-#include "reo.h"
-
-ABC_NAMESPACE_IMPL_START
-
-
-////////////////////////////////////////////////////////////////////////
-///                        DECLARATIONS                              ///
-////////////////////////////////////////////////////////////////////////
-
-////////////////////////////////////////////////////////////////////////
-///                    FUNCTION DEFINITIONS                          ///
-////////////////////////////////////////////////////////////////////////
-
-/**Function*************************************************************
-
-  Synopsis    [Initializes the reordering engine.]
-
-  Description [The first argument is the max number of variables in the
-  CUDD DD manager which will be used with the reordering engine 
-  (this number of should be the maximum of BDD and ZDD parts). 
-  The second argument is the maximum number of BDD nodes in the BDDs 
-  to be reordered. These limits are soft. Setting lower limits will later 
-  cause the reordering manager to resize internal data structures. 
-  However, setting the exact values will make reordering more efficient 
-  because resizing will be not necessary.]
-
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-reo_man * Extra_ReorderInit( int nDdVarsMax, int nNodesMax )
-{
-	reo_man * p;
-	// allocate and clean the data structure
-	p = ABC_ALLOC( reo_man, 1 );
-	memset( p, 0, sizeof(reo_man) );
-	// resize the manager to meet user's needs	
-	reoResizeStructures( p, nDdVarsMax, nNodesMax, 100 );
-	// set the defaults
-	p->fMinApl   = 0;
-	p->fMinWidth = 0;
-	p->fRemapUp  = 0;
-	p->fVerbose  = 0;
-	p->fVerify   = 0;
-	p->nIters    = 1;
-	return p;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Disposes of the reordering engine.]
-
-  Description [Removes all memory associated with the reordering engine.]
-
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Extra_ReorderQuit( reo_man * p )
-{
-	ABC_FREE( p->pTops );
-	ABC_FREE( p->pSupp );
-	ABC_FREE( p->pOrderInt );
-	ABC_FREE( p->pWidthCofs );
-	ABC_FREE( p->pMapToPlanes );
-	ABC_FREE( p->pMapToDdVarsOrig );
-	ABC_FREE( p->pMapToDdVarsFinal );
-	ABC_FREE( p->pPlanes );
-	ABC_FREE( p->pVarCosts );
-	ABC_FREE( p->pLevelOrder );
-	ABC_FREE( p->HTable );
-	ABC_FREE( p->pRefNodes );
-	reoUnitsStopDispenser( p );
-	ABC_FREE( p->pMemChunks );
-	ABC_FREE( p );
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Sets the type of DD minimizationl that will be performed.]
-
-  Description [Currently, three different types of minimization are supported.
-  It is possible to minimize the number of BDD nodes. This is a classical type
-  of minimization, which is attempting to reduce the total number of nodes in
-  the (shared) BDD of the given Boolean functions. It is also possible to 
-  minimize the BDD width, defined as the sum total of the number of cofactors 
-  on each level in the (shared) BDD (note that the number of cofactors on the 
-  given level may be larger than the number of nodes appearing on the given level).
-  It is also possible to minimize the average path length in the (shared) BDD 
-  defined as the sum of products, for all BDD paths from the top node to any 
-  terminal node, of the number of minterms on the path by the number of nodes 
-  on the path. The default reordering type is minimization for the number of 
-  BDD nodes. Calling this function with REO_MINIMIZE_WIDTH or REO_MINIMIZE_APL
-  as the second argument, changes the default minimization option for all the 
-  reorder calls performed afterwards.]
-
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Extra_ReorderSetMinimizationType( reo_man * p, reo_min_type fMinType )
-{
-	if ( fMinType == REO_MINIMIZE_NODES ) 
-	{
-		p->fMinWidth = 0;
-		p->fMinApl   = 0;
-	}
-	else if ( fMinType == REO_MINIMIZE_WIDTH )
-	{
-		p->fMinWidth = 1;
-		p->fMinApl   = 0;
-	}
-	else if ( fMinType == REO_MINIMIZE_APL )
-	{
-		p->fMinWidth = 0;
-		p->fMinApl   = 1;
-	}
-	else 
-	{
-		assert( 0 );
-	}
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Sets the type of remapping performed by the engine.]
-
-  Description [The remapping refers to the way the resulting BDD
-  is expressed using the elementary variables of the CUDD BDD manager.
-  Currently, two types possibilities are supported: remapping and no
-  remapping. Remapping means that the function(s) after reordering
-  depend on the topmost variables in the manager. No remapping means 
-  that the function(s) after reordering depend on the same variables 
-  as before. Consider the following example. Suppose the initial four
-  variable function depends on variables 2,4,5, and 9 on the CUDD BDD
-  manager, which may be found anywhere in the current variable order.
-  If remapping is set, the function after ordering depends on the 
-  topmost variables in the manager, which may or may not be the same
-  as the variables 2,4,5, and 9. If no remapping is set, then the 
-  reordered function depend on the same variables 2,4,5, and 9, but
-  the meaning of each variale has changed according to the new ordering.
-  The resulting ordering is returned in the array "pOrder" filled out
-  by the reordering engine in the call to Extra_Reorder(). The default
-  is no remapping.]
-
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Extra_ReorderSetRemapping( reo_man * p, int fRemapUp )
-{
-	p->fRemapUp = fRemapUp;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Sets the number of iterations of sifting performed.]
-
-  Description [The default is one iteration. But a higher minimization
-  quality is desired, it is possible to set the number of iterations 
-  to any number larger than 1. Convergence is often reached after
-  several iterations, so typically it make no sense to set the number
-  of iterations higher than 3.]
-
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Extra_ReorderSetIterations( reo_man * p, int nIters )
-{
-	p->nIters = nIters;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Sets the verification mode.]
-
-  Description [Setting the level to 1 results in verifying the results
-  of variable reordering. Verification is performed by remapping the
-  resulting functions into the original variable order and comparing
-  them with the original functions given by the user. Enabling verification
-  typically leads to 20-30% increase in the total runtime of REO.]
-
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Extra_ReorderSetVerification( reo_man * p, int fVerify )
-{
-	p->fVerify = fVerify;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Sets the verbosity level.]
-
-  Description [Setting the level to 1 results in printing statistics
-  before and after the reordering.]
-
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Extra_ReorderSetVerbosity( reo_man * p, int fVerbose )
-{
-	p->fVerbose = fVerbose;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Performs reordering of the function.]
-
-  Description [Returns the DD minimized by variable reordering in the REO 
-  engine. Takes the CUDD decision diagram manager (dd) and the function (Func) 
-  represented as a BDD or ADD (MTBDD). If the variable array (pOrder) is not NULL, 
-  returns the resulting  variable permutation. The permutation is such that if the resulting 
-  function is permuted by Cudd_(add,bdd)Permute() using pOrder as the permutation 
-  array, the initial function (Func) results.
-  Several flag set by other interface functions specify reordering options: 
-  - Remappig can be set by Extra_ReorderSetRemapping(). Then the resulting DD after 
-  reordering is remapped into the topmost levels of the DD manager. Otherwise, 
-  the resulting DD after reordering is mapped using the same variables, on which it 
-  originally depended, only (possibly) permuted as a result of reordering.
-  - Minimization type can be set by Extra_ReorderSetMinimizationType(). Note
-  that when the BDD is minimized for the total width of the total APL, the number
-  BDD nodes can increase. The total width is defines as sum total of widths on each 
-  level. The width on one level is defined as the number of distinct BDD nodes 
-  pointed by the nodes situated above the given level.
-  - The number of iterations of sifting can be set by Extra_ReorderSetIterations().
-  The decision diagram returned by this procedure is not referenced.]
-
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-DdNode * Extra_Reorder( reo_man * p, DdManager * dd, DdNode * Func, int * pOrder )
-{
-	DdNode * FuncRes;
-	Extra_ReorderArray( p, dd, &Func, &FuncRes, 1, pOrder );
-	Cudd_Deref( FuncRes );
-	return FuncRes;
-}
-
-/**Function*************************************************************
-
-  Synopsis    [Performs reordering of the array of functions.]
-
-  Description [The options are similar to the procedure Extra_Reorder(), except that
-  the user should also provide storage for the resulting DDs, which are returned 
-  referenced.]
-
-  SideEffects []
-
-  SeeAlso     []
-
-***********************************************************************/
-void Extra_ReorderArray( reo_man * p, DdManager * dd, DdNode * Funcs[], DdNode * FuncsRes[], int nFuncs, int * pOrder )
-{
-	reoReorderArray( p, dd, Funcs, FuncsRes, nFuncs, pOrder );
-}
-
-
-////////////////////////////////////////////////////////////////////////
-///                         END OF FILE                              ///
-////////////////////////////////////////////////////////////////////////
-
-ABC_NAMESPACE_IMPL_END
-