Bool state_hashed( State S ) { int i, sum, index; StateHashEntry *h; sum = state_sum( S ); index = sum & STATE_HASH_BITS; h = lstate_hash_entry[index]; for ( i = 0; i < lnum_state_hash_entry[index]; i++ ) { if ( h->sum != sum ) { h = h->next; continue; } if ( same_state( &(h->S), &S ) ) { return TRUE; } h = h->next; } return FALSE; }
Bool ehc_state_hashed( State *S ) { int i, sum, index; EhcHashEntry *h; sum = state_sum( S ); index = sum & EHC_HASH_BITS; h = lehc_hash_entry[index]; for ( i = 0; i < lnum_ehc_hash_entry[index]; i++ ) { if ( h->sum != sum ) { h = h->next; continue; } if ( same_state( &(h->ehc_node->S), S ) ) { return TRUE; } h = h->next; } return FALSE; }
int state_seen( int num ) { int i; for ( i = 0; i <= gnum_plan_ops; i++ ) { if ( gplan_states_sum[i] != gplan_states_sum[num] ) { continue; } if ( same_state( &gplan_states[i], &gplan_states[num] ) ) { return i; } } return -1; }
/*add the state S into hash table*/ PlanHashEntry *hash_plan_state( State *S, int step ) { int sum, index; PlanHashEntry *h, *tmp; sum = state_sum( S ); index = sum & PLAN_HASH_BITS; for ( h = lplan_hash_entry[index]; h; h = h->next ) { if ( h->sum != sum ) continue; if ( same_state( S, &(h->S) ) ) break; } /*found the same state in the hash table*/ if ( h ) { if ( h->step != -1 ) { printf("\n\n[error]:reencountering a state that is already in plan! debug me\n\n"); exit( 1 ); } h->step = step; return h; } /* not found the same state in hash table*/ /* h points to the last one*/ /* jovi: comments by jovi, seems it is not necessary * This is for addding a nes state */ for ( h = lplan_hash_entry[index]; h && h->next; h = h->next ) ; tmp = new_PlanHashEntry(); tmp->sum = sum; copy_source_to_dest( &(tmp->S), S ); tmp->step = step; if ( h ) { h->next = tmp; } else { lplan_hash_entry[index] = tmp; } return tmp; }
PlanHashEntry *plan_state_hashed(State *S) { int sum, index; PlanHashEntry *h; sum = state_sum(S); index = sum & PLAN_HASH_BITS; for (h = lplan_hash_entry[index]; h; h = h->next) { if (h->sum != sum) continue; if (same_state(S, &(h->S))) break; } if (h && h->step != -1) { return h; } return NULL; }
PlanHashEntry *hash_plan_state( State *S, int step ) { int sum, index; PlanHashEntry *h, *tmp; sum = state_sum( S ); index = sum & PLAN_HASH_BITS; for ( h = lplan_hash_entry[index]; h; h = h->next ) { if ( h->sum != sum ) continue; if ( same_state( S, &(h->S) ) ) break; } if ( h ) { if ( h->step != -1 ) { printf("\n\nreencountering a state that is already in plan! debug me\n\n"); exit( 1 ); } h->step = step; return h; } for ( h = lplan_hash_entry[index]; h && h->next; h = h->next ); tmp = new_PlanHashEntry(); tmp->sum = sum; copy_source_to_dest( &(tmp->S), S ); tmp->step = step; if ( h ) { h->next = tmp; } else { lplan_hash_entry[index] = tmp; } return tmp; }
/* breath first search */ int expand_first_node( int h ) { static Bool fc = TRUE; static State S_; int h_, i, g; if ( fc ) { make_state( &S_, gnum_ft_conn ); S_.max_F = gnum_ft_conn; fc = FALSE; } h_ = get_1P_and_H( &(lehc_current_start->S), &lcurrent_goals ); if ( h_ == INFINITY ) { lehc_current_start = lehc_current_start->next; return h_; } if ( lehc_current_start->new_goal != -1 && new_goal_gets_deleted( lehc_current_start ) ) { lehc_current_start = lehc_current_start->next; return INFINITY; } if ( h_ < h ) { return h_; } for ( i = 0; i < gnum_H; i++ ) { /*JC: dismiss invalid actions*/ int k; Bool found = FALSE; for(k = 0; k < gnum_IV; k++){ if(same_state(&gInvActs[k].state, &(lehc_current_start->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_, &(lehc_current_start->S), gH[i] ); add_to_ehc_space( &S_, gH[i], lehc_current_start, g ); } for ( i = 0; i < gnum_H; i++ ) { /*JC: dismiss invalid actions*/ int k; Bool found = FALSE; for(k = 0; k < gnum_IV; k++){ if(same_state(&gInvActs[k].state, &(lehc_current_start->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_, &(lehc_current_start->S), gH[i] ); add_to_ehc_space( &S_, gH[i], lehc_current_start, g ); } lehc_current_start = lehc_current_start->next; return h_; }
/************************************************* * 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; }