Bool search_A_for_better_state( State S, int h, State *S_, int *h_ )
{
int i, h__;
State S__;
lspace_start = 0;
lspace_end = 0;
lspace_size = 0;
hash_state( S );
for ( i = 0; i < gnum_A; i++ ) {
result_to_dest( &S__, S, gA[i] );
add_to_search_space( S__, gA[i], -1 );
}
while ( TRUE ) {
if ( lspace_start == lspace_end ) {
return FALSE;
}
h__ = expand_A_first_node( h );
if ( LESS( h__, h ) ) {
break;
}
}
reset_hash_entrys();
extract_plan_fragment();
source_to_dest( S_, lsearch_space[lspace_start].S );
*h_ = h__;
if ( lsearch_space[lspace_start].depth > gmax_search_depth ) {
gmax_search_depth = lsearch_space[lspace_start].depth;
}
if ( lspace_size > gmax_search_size ) {
gmax_search_size = lspace_size;
}
return TRUE;
}
Bool search_for_better_state( State *S, int h, State *S_, int *h_ )
{
static Bool first_call = TRUE;
static State S__;
int i, h__, depth = 0;
EhcNode *tmp;
if ( first_call ) {
make_state( &S__, gnum_ft_conn );
first_call = FALSE;
}
/* don't hash states, but search nodes.
* this way, don't need to keep states twice in memory
*/
tmp = new_EhcNode();
copy_source_to_dest( &(tmp->S), S);
hash_ehc_node( tmp );
lehc_current_end = lehc_space_head->next;
for ( i = 0; i < gnum_H; i++ ) {
/* see result-to-dest params explanation at fn header
*/
if ( !result_to_dest( &S__, tmp, NULL, gH[i] ) ) continue;
add_to_ehc_space( &S__, gH[i], tmp );
}
lehc_current_start = lehc_space_head->next;
while ( TRUE ) {
if ( lehc_current_start == lehc_current_end ) {
reset_ehc_hash_entrys();
free( tmp );
return FALSE;
}
if ( lehc_current_start->depth > depth ) {
depth = lehc_current_start->depth;
if ( depth > gmax_search_depth ) {
gmax_search_depth = depth;
}
printf("[%d]", depth);
fflush( stdout );
/* HACK: if this is going to more than 15, then most likely this is just a stupid
* effect of helpful actions pruning, and we won't get anywhere anyway.
*/
if ( depth > 15 ) {
reset_ehc_hash_entrys();
free( tmp );
return FALSE;
}
}
h__ = expand_first_node( h );
if ( LESS( h__, h ) ) {
break;
}
}
reset_ehc_hash_entrys();
free( tmp );
extract_plan_fragment( S );
source_to_dest( S_, &(lehc_current_start->S) );
*h_ = h__;
return TRUE;
}
/*************************************************
* FUNCTIONS FOR BREADTH FIRST SEARCH IN H SPACE *
*************************************************/
Bool search_for_better_state_for_multiple_purpose ( State *S, int h, State *S_, int *h_ ) {
static Bool first_call_for_multiple_purpose = TRUE;
static State S__;
int i, h__, depth = 0, g;
EhcNode *tmp;
if ( first_call_for_multiple_purpose ) {
make_state( &S__, gnum_ft_conn );
S__.max_F = gnum_ft_conn;
first_call_for_multiple_purpose = FALSE;
}
/* don't hash states, but search nodes.
* this way, don't need to keep states twice in memory */
tmp = new_EhcNode();
copy_source_to_dest( &(tmp->S), S);
hash_ehc_node( tmp );
lehc_current_end = lehc_space_head->next;
for ( i = 0; i < gnum_H; i++ ) {
int k;
Bool found = FALSE;
for(k = 0; k < gnum_IV; k++){
if(same_state(&gInvActs[k].state, S) && gH[i] == gInvActs[k].act){
found = TRUE;
break;
}
}
if(found) continue;
if(is_D_action(gop_conn[gH[i]].action->name)) continue;
g = result_to_dest( &S__, S, gH[i] );
add_to_ehc_space( &S__, gH[i], NULL, g );
}
for ( i = 0; i < gnum_H; i++ ) {
int k;
Bool found = FALSE;
for(k = 0; k < gnum_IV; k++){
if(same_state(&gInvActs[k].state, S) && gH[i] == gInvActs[k].act){
found = TRUE;
break;
}
}
if(found) continue;
if(!is_D_action(gop_conn[gH[i]].action->name)) continue;
/* D_cation, not in the gH */
g = result_to_dest( &S__, S, gH[i] );
add_to_ehc_space( &S__, gH[i], NULL, g );
}
lehc_current_start = lehc_space_head->next;
while ( TRUE ) {
if ( lehc_current_start == lehc_current_end ) {
reset_ehc_hash_entrys();
free( tmp );
return FALSE;
}
if ( lehc_current_start->depth > depth ) {
depth = lehc_current_start->depth;
if ( depth > gmax_search_depth ) {
gmax_search_depth = depth;
}
printf("[%d]", depth);
fflush( stdout );
}
h__ = expand_first_node( h );
if ( LESS( h__, h ) ) {
break;
}
}
reset_ehc_hash_entrys();
free( tmp );
extract_plan_fragment( S );
source_to_dest( S_, &(lehc_current_start->S) );
*h_ = h__;
return TRUE;
}
Bool search_for_better_state( State *S, int h, State *S_, int *h_ )
{
static Bool first_call = TRUE;
static State S__;
int i, h__, depth = 0, g;
EhcNode *tmp;
if ( first_call ) {
make_state( &S__, gnum_ft_conn );
S__.max_F = gnum_ft_conn;
first_call = FALSE;
}
/* don't hash states, but search nodes.
* this way, don't need to keep states twice in memory
*/
tmp = new_EhcNode();
copy_source_to_dest( &(tmp->S), S);
hash_ehc_node( tmp );
lehc_current_end = lehc_space_head->next;
for ( i = 0; i < gnum_H; i++ ) {
g = result_to_dest( &S__, S, gH[i] );
add_to_ehc_space( &S__, gH[i], NULL, g );
}
lehc_current_start = lehc_space_head->next;
while ( TRUE ) {
if ( lehc_current_start == lehc_current_end ) {
reset_ehc_hash_entrys();
free( tmp );
return FALSE;
}
if ( lehc_current_start->depth > depth ) {
depth = lehc_current_start->depth;
if ( depth > gmax_search_depth ) {
gmax_search_depth = depth;
}
printf("[%d]", depth);
fflush( stdout );
}
h__ = expand_first_node( h );
if ( LESS( h__, h ) ) {
break;
}
}
reset_ehc_hash_entrys();
free( tmp );
extract_plan_fragment( S );
source_to_dest( S_, &(lehc_current_start->S) );
*h_ = h__;
return TRUE;
}
