plaMan.c

Go to the documentation of this file.

 
#include "pla.h"
 
ABC_NAMESPACE_IMPL_START



void Pla_GenSorter( int nVars )
{
    int i, k, Count, nMints = ( 1 << nVars );
    char Buffer[20];
    FILE * pFile;
    sprintf( Buffer, "sorter%02d.pla", nVars );
    pFile = fopen( Buffer, "wb" );
    fprintf( pFile, "# This file was generated by ABC on %s.\n", Extra_TimeStamp() );
    fprintf( pFile, ".i %d\n", nVars );
    fprintf( pFile, ".o %d\n", nVars );
    fprintf( pFile, ".p %d\n", nMints-1 );
    for ( i = 1; i < nMints; i++ )
    {
        Count = 0;
        for ( k = nVars-1; k >= 0; k-- )
        {
            Count += ((i >> k) & 1);
            fprintf( pFile, "%d", (i >> k) & 1 );
        }
        fprintf( pFile, " " );
        for ( k = 0; k < Count; k++ )
            fprintf( pFile, "1" );
        for (      ; k < nVars; k++ )
            fprintf( pFile, "0" );
        fprintf( pFile, "\n" );
    }
    fprintf( pFile, ".end\n" );
    fclose( pFile );
}

Vec_Bit_t * Pla_ManPrimesTable( int nVars )
{
    int i, n, nBits = 1 << nVars;
    Vec_Bit_t * vMap = Vec_BitStartFull( Abc_MaxInt(64, nBits) );
    for ( i = nBits; i < 64; i++ )
        Vec_BitWriteEntry( vMap, i, 0 );
    Vec_BitShrink( vMap, nBits );
    Vec_BitWriteEntry( vMap, 0, 0 );
    Vec_BitWriteEntry( vMap, 1, 0 );
    for ( n = 2; n < nBits; n++ )
        if ( Vec_BitEntry(vMap, n) )
            for ( i = 2*n; i < nBits; i += n )
                Vec_BitWriteEntry( vMap, i, 0 );
    return vMap;
}
Vec_Int_t * Pla_GenPrimes( int nVars )
{
    int n, nBits = ( 1 << nVars );
    Vec_Int_t * vPrimes = Vec_IntAlloc( 1000 );
    Vec_Bit_t * vMap = Pla_ManPrimesTable( nVars );
    for ( n = 2; n < nBits; n++ )
        if ( Vec_BitEntry(vMap, n) )
            Vec_IntPush( vPrimes, n );
    printf( "Primes up to 2^%d = %d\n", nVars, Vec_IntSize(vPrimes) );
//    Abc_GenCountHits1( vMap, vPrimes, nVars );
    Vec_BitFree( vMap );
    return vPrimes;
}
Pla_Man_t * Pla_GenFromMinterms( char * pName, Vec_Int_t * vMints, int nVars )
{
    Pla_Man_t * p = Pla_ManAlloc( pName, nVars, 1, Vec_IntSize(vMints) );
    int i, k, Lit, Mint;
    word * pCube;
    Pla_ForEachCubeIn( p, pCube, i )
    {
        Mint = Vec_IntEntry(vMints, i);
        Pla_CubeForEachLitIn( p, pCube, Lit, k )
            Pla_CubeSetLit( pCube, k, ((Mint >> k) & 1) ? PLA_LIT_ONE : PLA_LIT_ZERO );
    }
    Pla_ForEachCubeOut( p, pCube, i )
        Pla_CubeSetLit( pCube, 0, PLA_LIT_ONE );
    return p;
}
Pla_Man_t * Pla_ManPrimesDetector( int nVars )
{
    char pName[1000];
    Pla_Man_t * p;
    Vec_Int_t * vMints = Pla_GenPrimes( nVars );
    sprintf( pName, "primes%02d", nVars );
    p = Pla_GenFromMinterms( pName, vMints, nVars );
    Vec_IntFree( vMints );
    return p;
}

Vec_Bit_t * Pla_GenRandom( int nVars, int nNums, int fNonZero )
{
    int Mint, Count = 0;
    Vec_Bit_t * vBits = Vec_BitStart( 1 << nVars );
    assert( nVars > 0 && nVars <= 30 );
    assert( nNums > 0 && nNums < (1 << (nVars - 1)) );
    while ( Count < nNums )
    {
        Mint = Gia_ManRandom(0) & ((1 << nVars) - 1);
        if ( fNonZero && Mint == 0 )
            continue;
        if ( Vec_BitEntry(vBits, Mint) )
            continue;
        Vec_BitWriteEntry( vBits, Mint, 1 );
        Count++;
    }
    return vBits;
}
Pla_Man_t * Pla_ManGenerate( int nInputs, int nOutputs, int nCubes, int fVerbose )
{
    Pla_Man_t * p;
    Vec_Bit_t * vBits;
    int i, k, Count;
    word * pCube;
    char Buffer[1000];
    sprintf( Buffer, "%s_%d_%d_%d", "rand", nInputs, nOutputs, nCubes );
    p = Pla_ManAlloc( Buffer, nInputs, nOutputs, nCubes );
    // generate nCube random input minterms
    vBits = Pla_GenRandom( nInputs, nCubes, 0 );
    for ( i = Count = 0; i < Vec_BitSize(vBits); i++ )
        if ( Vec_BitEntry(vBits, i) )
        {
            pCube = Pla_CubeIn( p, Count++ );
            for ( k = 0; k < nInputs; k++ )
                Pla_CubeSetLit( pCube, k, ((i >> k) & 1) ? PLA_LIT_ONE : PLA_LIT_ZERO );
        }
    assert( Count == nCubes );
    Vec_BitFree( vBits );
    // generate nCube random output minterms
    if ( nOutputs > 1 )
    {
        vBits = Pla_GenRandom( nOutputs, nCubes, 1 );
        for ( i = Count = 0; i < Vec_BitSize(vBits); i++ )
            if ( Vec_BitEntry(vBits, i) )
            {
                pCube = Pla_CubeOut( p, Count++ );
                for ( k = 0; k < nOutputs; k++ )
                    Pla_CubeSetLit( pCube, k, ((i >> k) & 1) ? PLA_LIT_ONE : PLA_LIT_ZERO );
            }
        assert( Count == nCubes );
        Vec_BitFree( vBits );
    }
    else
    {
        Pla_ForEachCubeOut( p, pCube, i )
            Pla_CubeSetLit( pCube, 0, PLA_LIT_ONE );
    }
    return p;
}

void Pla_ManConvertFromBits( Pla_Man_t * p )
{
    Vec_Int_t * vCube;
    word * pCube; int i, k, Lit, Count;
    Vec_WecClear( &p->vCubeLits );
    Vec_WecClear( &p->vOccurs );
    Vec_WecInit( &p->vCubeLits, Pla_ManCubeNum(p) );
    Vec_WecInit( &p->vOccurs, 2*Pla_ManInNum(p) );
    Pla_ForEachCubeIn( p, pCube, i )
    {
        vCube = Vec_WecEntry( &p->vCubeLits, i );
 
        Count = 0;
        Pla_CubeForEachLitIn( p, pCube, Lit, k )
            if ( Lit != PLA_LIT_DASH )
                Count++;
        Vec_IntGrow( vCube, Count );
 
        Count = 0;
        Pla_CubeForEachLitIn( p, pCube, Lit, k )
            if ( Lit != PLA_LIT_DASH )
            {
                Lit = Abc_Var2Lit( k, Lit == PLA_LIT_ZERO );
                Vec_WecPush( &p->vCubeLits, i, Lit );
//                Vec_WecPush( &p->vOccurs, Lit, Pla_CubeHandle(i, Count++) );
                Vec_WecPush( &p->vOccurs, Lit, i );
            }
        assert( Vec_IntSize(vCube) == Vec_IntCap(vCube) );
    }
}
void Pla_ManConvertToBits( Pla_Man_t * p )
{
    Vec_Int_t * vCube; int i, k, Lit;
    Vec_IntFillNatural( &p->vCubes, Vec_WecSize(&p->vCubeLits) );
    Vec_WrdFill( &p->vInBits,  Pla_ManCubeNum(p) * p->nInWords,  0 );
    Vec_WecForEachLevel( &p->vCubeLits, vCube, i )
        Vec_IntForEachEntry( vCube, Lit, k )
            Pla_CubeSetLit( Pla_CubeIn(p, i), Abc_Lit2Var(Lit), Abc_LitIsCompl(Lit) ? PLA_LIT_ZERO : PLA_LIT_ONE );
}

int Pla_ManDist1Num( Pla_Man_t * p )
{
    word * pCube1, * pCube2; 
    int i, k, Dist, Count = 0;
    Pla_ForEachCubeIn( p, pCube1, i )
    Pla_ForEachCubeInStart( p, pCube2, k, i+1 )
    {
        Dist = Pla_CubesAreDistance1( pCube1, pCube2, p->nInWords );
//        Dist = Pla_CubesAreConsensus( pCube1, pCube2, p->nInWords, NULL );
        Count += (Dist == 1);
    }
    return Count;
}
int Pla_ManDist1NumTest( Pla_Man_t * p )
{
    abctime clk = Abc_Clock();
    int Count = Pla_ManDist1Num( p );
    printf( "Found %d pairs among %d cubes using cube pair enumeration.  ", Count, Pla_ManCubeNum(p) );
    Abc_PrintTime( 1, "Time", Abc_Clock() - clk );
    return 1;
}

 
 
ABC_NAMESPACE_IMPL_END