Example #1
0
Clause*
Component::getClauseToPropagate(
    Learning& learning )
{
    begin:;
    if( unfoundedSet.empty() )
    {
        assert( !done );
        clauseToPropagate = NULL;
        
        assert( !variablesWithoutSourcePointer.empty() || checkSourcePointersStatus() );
        assert( !variablesWithoutSourcePointer.empty() || checkFoundedStatus() );
        if( variablesWithoutSourcePointer.empty() )
            return NULL;
             
        if( first )
            computeGUSFirst();
        else
            computeGUS();
        
        assert( !unfoundedSet.empty() || variablesWithoutSourcePointer.empty() );
        assert( !unfoundedSet.empty() || checkSourcePointersStatus() );
        assert( !unfoundedSet.empty() || checkFoundedStatus() );
        if( unfoundedSet.empty() )
            return NULL;
        assert( clauseToPropagate == NULL );
        clauseToPropagate = learning.learnClausesFromUnfoundedSet( unfoundedSet );
        clausesToDelete.push_back( clauseToPropagate );
        trace_msg( unfoundedset, 2, "Reasons of unfounded sets: " << *clauseToPropagate );
        goto begin;
    }
    else
    {
        assert( clauseToPropagate != NULL );
        
        if( done )
        {
            Var variable = updateClauseToPropagate();
            if( variable == 0 )
            {
                assert( unfoundedSet.empty() );
                done = 0;
                clauseToPropagate = NULL;
                goto begin;
            }
            
            Clause* c = clauseToPropagate;
            if( solver.isTrue( variable ) )
            {
                assert( c->getAt( 0 ) == Literal( variable, FALSE ) );
                assert( solver.getDecisionLevel( variable ) == solver.getCurrentDecisionLevel() );

                c = new Clause( clauseToPropagate->size() );
                c->copyLiterals( *clauseToPropagate );
                if( solver.glucoseHeuristic() )
                    c->setLbd( clauseToPropagate->lbd() );
                c->setLearned();
                reset();
                assert( !done );
                assert( clauseToPropagate == NULL );
            }
            return c;              
        }
        
        if( conflict != 0 )
            return handleConflict();

        //Keep small clauses
        if( clauseToPropagate->size() <= 3 || unfoundedSet.size() == 1 )
        {
            Clause* c = inferFalsityOfUnfoundedAtoms();
            if( c != NULL )
                return c;

            goto begin;
        }
                        
        assert( unfoundedSet.size() >= 2 );        
        assert( clauseToPropagate->size() > 3 );
        
        assert( !done );
        clauseToPropagate->addLiteralInLearnedClause( Literal::null );
        clauseToPropagate->swapLiterals( 0, 1 );
        clauseToPropagate->swapLiterals( 0, clauseToPropagate->size() - 1 );

//        assert( unfoundedSet.empty() );
//        clauseToPropagate = NULL;
        done = 1;
        goto begin;
//        return NULL;
    }

    goto begin;
}