void print_Action( Action *a )
{
ActionEffect *e;
int i, j;
if ( !a->norm_operator &&
!a->pseudo_action ) {
printf("\n\nAction REACH-GOAL");
} else {
printf("\n\nAction %s", a->name );
for ( i = 0; i < a->num_name_vars; i++ ) {
printf(" %s", gconstants[a->name_inst_table[i]]);
}
}
printf("\n\nPreconds:\n");
for ( i = 0; i < a->num_preconds; i++ ) {
print_ft_name( a->preconds[i] );
printf("\n");
}
printf("\n\nEffects:");
for ( j = 0; j < a->num_effects; j++ ) {
printf("\n\neffect %d", j);
e = &(a->effects[j]);
printf("\n\nConditions, P %lf:\n", e->eff_p);/* july 06 */
for ( i = 0; i < e->num_conditions; i++ ) {
print_ft_name( e->conditions[i] );
printf("\n");
}
printf("\nAdds\n");
for ( i = 0; i < e->num_adds; i++ ) {
print_ft_name( e->adds[i] );
printf("\n");
}
printf("\nDels\n");
for ( i = 0; i < e->num_dels; i++ ) {
print_ft_name( e->dels[i] );
printf("\n");
}
}
}
void print_state( State S )
{
int i;
printf("\nF:");
for ( i = 0; i < S.num_F; i++ ) {
printf("\n");
print_ft_name( S.F[i] );
}
printf("\nU:");
for ( i = 0; i < S.num_U; i++ ) {
printf("\n");
print_ft_name( S.U[i] );
}
}
void print_fixpoint_result( void )
{
int time, i;
Bool hit, hit_F, hit_E;
time = 0;
while ( 1 ) {
hit = FALSE;
hit_F = FALSE;
hit_E = FALSE;
for ( i = 0; i < gnum_ft_conn; i++ ) {
if ( gft_conn[i].level == time ) {
hit = TRUE;
hit_F = TRUE;
break;
}
}
for ( i = 0; i < gnum_ef_conn; i++ ) {
if ( gef_conn[i].level == time ) {
hit = TRUE;
hit_E = TRUE;
break;
}
}
if ( !hit ) {
break;
}
printf("\n\nLEVEL %d:", time);
if ( hit_F ) {
printf("\n\nFACTS:");
for ( i = 0; i < gnum_ft_conn; i++ ) {
if ( gft_conn[i].level == time ) {
printf("\n");
print_ft_name( i );
}
}
}
if ( hit_E ) {
printf("\n\nEFS:");
for ( i = 0; i < gnum_ef_conn; i++ ) {
if ( gef_conn[i].level == time ) {
printf("\neffect %d to ", i);
print_op_name( gef_conn[i].op );
}
}
}
time++;
}
fflush( stdout );
}
void print_state( State *S )
{
int i;
printf("\n{");
for ( i = 0; i < S->num_F; i++ ) {
print_ft_name( S->F[i] );
printf(", ");
}
printf("}\n");
}
void print_State( State S )
{
int i;
for ( i = 0; i < S.num_F; i++ ) {
printf("\n");
print_ft_name( S.F[i] );
}
for ( i = 0; i < gnum_relevant_fluents; i++ ) {
printf("\n");
print_fl_name( i );
printf(": ");
if ( S.f_D[i] ) {
printf("%.2f", S.f_V[i]);
} else {
printf("UNDEF");
}
}
}
void print_ft_name( int index )
{
/* july 06: fixed old bug -- with -i 120, the conn has not been built yet
* so the below gave a seg fault.
*/
if ( !gft_conn ) {
print_Fact( &(grelevant_facts[index]) );
return;
}
if ( gft_conn[index].is_state_var ) {
print_Fact( &(grelevant_facts[index]) );
} else {
/* artificial chance var;
*/
printf("(CHANCE %f/%f row %d ",
gft_conn[index].weight_a, gft_conn[index].weight_b, gft_conn[index].cpt_row);
print_ft_name(gft_conn[index].chance_var_for);
printf(")");
}
}
/* take RPG layer t, insert actions into t,
* create next layer tpp and insert facts and fluent stuff,
* return tpp.
*/
RPGlayer *RPG_extend( RPGlayer *t )
{
RPGlayer *tpp;
RPGfact *p, *prevp, *ip;
RPGvalue *v, *prevv, *iv;
RPGaction *a;
RPGeffect *e, *ie;
int i, j, k;
Action *ga;
ActionEffect *ge;
if ( gcmd_line.debug && gcmd_line.dRPG ) {
printf("\n\n\n\nextending RPG.");
}
tpp = new_RPGlayer();
tpp->t = t->t+1;
tpp->prev = t;
t->next = tpp;
/* initialize facts to facts at t.
*/
tpp->P = new_RPGfact();
tpp->is_P = ( Bool * ) calloc(gnum_relevant_facts, sizeof( Bool ));
for ( i = 0; i < gnum_relevant_facts; i++ ) {
tpp->is_P[i] = FALSE;
}
prevp = tpp->P;
for ( ip = t->P->next; ip; ip = ip->next ) {
p = new_RPGfact();
p->p = ip->p;
p->id = ip->id;
tpp->is_P[p->id] = TRUE;
p->prev = prevp;
prevp->next = p;
prevp = p;
}
tpp->endP = prevp;
/* initialize fluent values to fluent values at t.
*/
tpp->V = ( RPGvalue_pointer * ) calloc(gnum_relevant_fluents, sizeof(RPGvalue_pointer));
for ( i = 0; i < gnum_relevant_fluents; i++ ) {
tpp->V[i] = new_RPGvalue();
prevv = tpp->V[i];
for ( iv = t->V[i]->next; iv; iv = iv->next ) {
v = new_RPGvalue();
v->v = iv->v;
v->prev = prevv;
prevv->next = v;
prevv = v;
}
}
/* the value tuples will be collected completely anew from tpp,
* once the values at tpp have been completed.
*
* NOTE: this may be made significantly more efficient by
* distinguishing between old and new var values, copying over the
* old tuples here, and collect new tuples below only for the new var
* values. skip for now since I don't expect all that many RPG layers
* anyway.
*
* NOTE however: actually i just tried the above (see OLD/)
* it's quite complicated since actually we have to build tuples
* not entirely out of new values, but so that they contain *at least*
* one new value. implementing this in the context here, with arbitrary
* expressions, doesn't strike me as very desirable...
* does not have much of an effect anyway, in most domains. leave it for now.
*/
/* constraint value tuples
*/
tpp->constraint_VT = ( RPGvaluetuple_pointer * )
calloc(gnum_relevant_constraints, sizeof(RPGvaluetuple_pointer));
for ( i = 0; i < gnum_relevant_constraints; i++ ) {
tpp->constraint_VT[i] = new_RPGvaluetuple();
}
/* psi value tuples
*/
tpp->psi_VT = ( RPGvaluetuple_pointer * )
calloc(gnum_relevant_psis, sizeof(RPGvaluetuple_pointer));
for ( i = 0; i < gnum_relevant_psis; i++ ) {
tpp->psi_VT[i] = new_RPGvaluetuple();
}
/* actions at t. don't copy anything over since we will have to
* re-consider each action anyway, to check for new numeric
* effects.
*/
t->A = new_RPGaction();
t->endA = t->A;
if ( gcmd_line.debug > 2 && gcmd_line.dRPG ) {
printf("\n\n\nfinished RPG copy. now is:");
RPG_print();
}
/* find the applicable actions/effects, and insert the new facts/values.
*/
i = 0;
for ( ga = gactions; ga; ga = ga->next ) {
if ( gcmd_line.debug && gcmd_line.dRPG ) {
printf("\ntrying action: "); print_Action_name(ga);
}
/* check applicability!
*/
if ( gcmd_line.debug && gcmd_line.dRPG ) {
printf("\napplicable checking");
}
if ( !RPG_a_applicable(t, ga) ) {
if ( gcmd_line.debug && gcmd_line.dRPG ) {
printf("\napplicable NO!");
}
i++;
continue;
}
if ( gcmd_line.debug && gcmd_line.dRPG ) {
printf("\napplicable YES!");
}
/* insert action!
*/
a = new_RPGaction();
a->a = ga;
a->id = i;
a->prev = t->endA;
t->endA->next = a;
t->endA = a;
a->E = new_RPGeffect();
/* check the effects.
*/
for ( j = 0; j < ga->num_effects; j++ ) {
ge = &(ga->effects[j]);
if ( gcmd_line.debug && gcmd_line.dRPG ) {
printf("\ntrying effect: %d", j);
}
/* check applicability!
*/
if ( gcmd_line.debug && gcmd_line.dRPG ) {
printf("\napplicable checking effect");
}
if ( !RPG_e_applicable(t, ge) ) {
if ( gcmd_line.debug && gcmd_line.dRPG ) {
printf("\napplicable NO!");
}
continue;
}
if ( gcmd_line.debug && gcmd_line.dRPG ) {
printf("\napplicable YES!");
}
/* insert effect!
*/
e = new_RPGeffect();
e->e = ge;
e->id = j;
/* find last list element.
* INEFFICIENT!
*
* probably not so bad since we don't expect single actions to
* have huge numbers of effects.
*/
for ( ie = a->E; ie->next; ie = ie->next );
e->prev = ie;
ie->next = e;
/* insert new added facts!
*/
for ( k = 0; k < ge->num_adds; k++ ) {
if ( gcmd_line.debug && gcmd_line.dRPG ) {
printf("\ntrying add effect: ");
print_ft_name(ge->adds[k]);
}
/* check if this is new!
*/
if ( RPG_P_contains(tpp, ge->adds[k]) ) {
if ( gcmd_line.debug && gcmd_line.dRPG ) {
printf(" not new!");
}
continue;
}
if ( gcmd_line.debug && gcmd_line.dRPG ) {
printf(" new!");
}
/* insert this into the facts.
*/
p = new_RPGfact();
p->p = &(grelevant_facts[ge->adds[k]]);
p->id = ge->adds[k];
tpp->is_P[p->id] = TRUE;
p->prev = tpp->endP;
tpp->endP->next = p;
tpp->endP = p;
} /* endfor k over adds of ge */
/* insert new fluent values!
*/
for ( k = 0; k < ge->num_numeric_effects; k++ ) {
RPG_insert_effect(t,
ge->con_psi_id,
ge->numeric_effects_fl[k],
ge->numeric_effects_neft[k],
ge->numeric_effects_rh[k]);
} /* endfor k over numeric effects of ge */
} /* endfor j over effects ge of ga */
i++;
} /* endfor ga over actions, index i kept up-to-date */
if ( gcmd_line.debug > 2 && gcmd_line.dRPG ) {
printf("\n\n\nfinished actions. now is:");
RPG_print();
}
/* now all values at tpp are inserted. we need to compute
* the extensions of the constraints and psis!
*/
for ( i = 0; i < gnum_relevant_constraints; i++ ) {
RPG_get_constraint_valuetuples(tpp, i);
}
for ( i = 0; i < gnum_relevant_psis; i++ ) {
RPG_get_psi_valuetuples(tpp, i);
}
if ( gcmd_line.debug > 2 && gcmd_line.dRPG ) {
printf("\n\n\nfinished constraints and psis. now is:");
RPG_print();
}
/* set up the connectivity info that will be needed
* for generation of frame and mutex clauses.
*
* associated to the *action* layer!
*/
RPG_get_connectivity(t);
return tpp;
}
void print_Action( Action *a )
{
ActionEffect *e;
int i, j;
if ( !a->norm_operator &&
!a->pseudo_action ) {
printf("\n\nAction REACH-GOAL");
} else {
printf("\n\nAction %s ID %d", a->name, a->id );
for ( i = 0; i < a->num_name_vars; i++ ) {
printf(" %s", gconstants[a->name_inst_table[i]]);
}
}
printf("\n\nPreconds:\n");
for ( i = 0; i < a->num_preconds; i++ ) {
print_ft_name( a->preconds[i] );
printf("\n");
}
for ( i = 0; i < a->num_numeric_preconds; i++ ) {
switch ( a->numeric_preconds_comp[i] ) {
case LE:
printf("(< ");
break;
case LEQ:
printf("(<= ");
break;
case EQ:
printf("(= ");
break;
case GEQ:
printf("(>= ");
break;
case GE:
printf("(> ");
break;
default:
printf("\nwrong comparator of Expnodes in actionpre %d\n\n",
a->numeric_preconds_comp[i]);
exit( 1 );
}
print_ExpNode( a->numeric_preconds_lh[i] );
print_ExpNode( a->numeric_preconds_rh[i] );
printf(")\n");
}
printf("\n\nEffects:");
for ( j = 0; j < a->num_effects; j++ ) {
e = &(a->effects[j]);
printf("\n\neffect %d ID %d", j, e->id);
printf("\n\nConditions\n");
for ( i = 0; i < e->num_conditions; i++ ) {
print_ft_name( e->conditions[i] );
printf("\n");
}
for ( i = 0; i < e->num_numeric_conditions; i++ ) {
switch ( e->numeric_conditions_comp[i] ) {
case LE:
printf("(< ");
break;
case LEQ:
printf("(<= ");
break;
case EQ:
printf("(= ");
break;
case GEQ:
printf("(>= ");
break;
case GE:
printf("(> ");
break;
default:
printf("\nwrong comparator of Expnodes in normeff %d\n\n",
e->numeric_conditions_comp[i]);
exit( 1 );
}
print_ExpNode( e->numeric_conditions_lh[i] );
print_ExpNode( e->numeric_conditions_rh[i] );
printf(")\n");
}
printf("\nAdds\n");
for ( i = 0; i < e->num_adds; i++ ) {
print_ft_name( e->adds[i] );
printf("\n");
}
printf("\nDels\n");
for ( i = 0; i < e->num_dels; i++ ) {
print_ft_name( e->dels[i] );
printf("\n");
}
for ( i = 0; i < e->num_numeric_effects; i++ ) {
switch ( e->numeric_effects_neft[i] ) {
case ASSIGN:
printf("\nassign ");
break;
case SCALE_UP:
printf("\nscale-up ");
break;
case SCALE_DOWN:
printf("\nscale-down ");
break;
case INCREASE:
printf("\nincrease ");
break;
case DECREASE:
printf("\ndecrease ");
break;
default:
printf("\n\nprint normop: illegal neft %d\n\n",
e->numeric_effects_neft[i]);
exit( 1 );
}
if ( e->numeric_effects_fl[i] >= 0 ) {
print_fl_name( e->numeric_effects_fl[i] );
} else {
printf("[UNDEF]");
}
print_ExpNode( e->numeric_effects_rh[i] );
}
}
}
void collect_relevant_facts( void )
{
Action *a;
NormOperator *no;
NormEffect *ne;
int i, j, adr;
PseudoAction *pa;
PseudoActionEffect *pae;
/* mark all deleted facts; such facts, that are also pos, are relevant.
*/
for ( a = gactions; a; a = a->next ) {
if ( a->norm_operator ) {
no = a->norm_operator;
for ( ne = no->effects; ne; ne = ne->next ) {
for ( i = 0; i < ne->num_dels; i++ ) {
lp = ne->dels[i].predicate;
for ( j = 0; j < garity[lp]; j++ ) {
largs[j] = ( ne->dels[i].args[j] >= 0 ) ?
ne->dels[i].args[j] : a->inst_table[DECODE_VAR( ne->dels[i].args[j] )];
}
adr = fact_adress();
lneg[lp][adr] = 1;
if ( lpos[lp][adr] &&
!luse[lp][adr] ) {
luse[lp][adr] = 1;
lindex[lp][adr] = gnum_relevant_facts;
if ( gnum_relevant_facts == MAX_RELEVANT_FACTS ) {
printf("\nincrease MAX_RELEVANT_FACTS! (current value: %d)\n\n",
MAX_RELEVANT_FACTS);
exit( 1 );
}
grelevant_facts[gnum_relevant_facts].predicate = lp;
for ( j = 0; j < garity[lp]; j++ ) {
grelevant_facts[gnum_relevant_facts].args[j] = largs[j];
}
lindex[lp][adr] = gnum_relevant_facts;
gnum_relevant_facts++;
}
}
}
} else {
pa = a->pseudo_action;
for ( pae = pa->effects; pae; pae = pae->next ) {
for ( i = 0; i < pae->num_dels; i++ ) {
lp = pae->dels[i].predicate;
for ( j = 0; j < garity[lp]; j++ ) {
largs[j] = pae->dels[i].args[j];
}
adr = fact_adress();
lneg[lp][adr] = 1;
if ( lpos[lp][adr] &&
!luse[lp][adr] ) {
luse[lp][adr] = 1;
lindex[lp][adr] = gnum_relevant_facts;
if ( gnum_relevant_facts == MAX_RELEVANT_FACTS ) {
printf("\nincrease MAX_RELEVANT_FACTS! (current value: %d)\n\n",
MAX_RELEVANT_FACTS);
exit( 1 );
}
grelevant_facts[gnum_relevant_facts].predicate = lp;
for ( j = 0; j < garity[lp]; j++ ) {
grelevant_facts[gnum_relevant_facts].args[j] = largs[j];
}
lindex[lp][adr] = gnum_relevant_facts;
gnum_relevant_facts++;
}
}
}
}
}
if ( gcmd_line.display_info == 119 ) {
printf("\n\nfacts selected as relevant:\n\n");
for ( i = 0; i < gnum_relevant_facts; i++ ) {
printf("\n%d: ", i);
print_Fact( &(grelevant_facts[i]) );
}
}
lnum_effects = 0;
// Chih-Wei
if (GpG.SearchModal != -2)
create_final_goal_state();
create_final_initial_state();
create_final_actions();
if ( gcmd_line.display_info == 120 ) {
printf("\n\nfinal domain representation is:\n\n");
for ( i = 0; i < gnum_operators; i++ ) {
printf("\n\n------------------operator %s-----------\n\n", goperators[i]->name);
for ( a = gactions; a; a = a->next ) {
if ( ( !a->norm_operator &&
!a->pseudo_action ) ||
( a->norm_operator &&
a->norm_operator->operator != goperators[i] ) ||
( a->pseudo_action &&
a->pseudo_action->operator != goperators[i] ) ) {
continue;
}
print_Action( a );
}
}
printf("\n\n--------------------GOAL REACHED ops-----------\n\n");
for ( a = gactions; a; a = a->next ) {
if ( !a->norm_operator &&
!a->pseudo_action ) {
print_Action( a );
}
}
printf("\n\nfinal initial state is:\n\n");
for ( i = 0; i < ginitial_state.num_F; i++ ) {
print_ft_name( ginitial_state.F[i] );
printf("\n");
}
printf("\n\nfinal goal state is:\n\n");
for ( i = 0; i < ggoal_state.num_F; i++ ) {
print_ft_name( ggoal_state.F[i] );
printf("\n");
}
}
}
void build_connectivity_graph( void )
{
int i, j, k, l, n_op, n_ef, m, na, nd;
Action *a;
int *same_effects, sn;
Bool *had_effects;
ActionEffect *e, *e_;
/*
* DEA - University of Brescia
*/
// struct timeb tp;
int tmpnum;
int sizeofgop, sizeofgef, sizeofgft;
sizeofgop = 0;
sizeofgef = 0;
sizeofgft = 0;
// ftime( &tp );
// srandom( tp.millitm );
srandom(seed);
/*
* End of DEA
*/
gnum_ft_conn = gnum_relevant_facts;
/*
* DEA - University of Brescia
*/
gnum_ft_block = gnum_ft_conn / 32 + 1;
/*
* End of DEA
*/
gnum_op_conn = gnum_actions;
gft_conn = ( FtConn * ) calloc( gnum_ft_conn, sizeof( FtConn ) );
gop_conn = ( OpConn * ) calloc( gnum_op_conn, sizeof( OpConn ) );
gef_conn = ( EfConn * ) calloc( lnum_effects, sizeof( EfConn ) );
gnum_ef_conn = 0;
same_effects = ( int * ) calloc( lnum_effects, sizeof( int ) );
had_effects = ( Bool * ) calloc( lnum_effects, sizeof( Bool ) );
for ( i = 0; i < gnum_ft_conn; i++ ) {
gft_conn[i].num_PC = 0;
gft_conn[i].num_A = 0;
gft_conn[i].num_D = 0;
/*
* DEA - University of Brescia
*/
// gft_conn[i].rand = random () % BIG_INT;
gft_conn[i].rand = MY_RANDOM % BIG_INT;
/*
* End of DEA
*/
}
for ( i = 0; i < gnum_op_conn; i++ ) {
gop_conn[i].num_E = 0;
}
for ( i = 0; i < gnum_ef_conn; i++ ) {
gef_conn[i].num_PC = 0;
gef_conn[i].num_A = 0;
gef_conn[i].num_D = 0;
gef_conn[i].num_I = 0;
}
n_op = 0;
n_ef = 0;
for ( a = gactions; a; a = a->next ) {
gop_conn[n_op].action = a;
gop_conn[n_op].E = ( int * ) calloc( a->num_effects, sizeof( int ) );
for ( i = 0; i < a->num_effects; i++ ) {
had_effects[i] = FALSE;
}
for ( i = 0; i < a->num_effects; i++ ) {
if ( had_effects[i] ) {
continue;
}
had_effects[i] = TRUE;
e = &(a->effects[i]);
gop_conn[n_op].E[gop_conn[n_op].num_E++] = n_ef;
gef_conn[n_ef].op = n_op;
sn = 0;
for ( j = i + 1; j < a->num_effects; j++ ) {
if ( had_effects[j] ) {
continue;
}
e_ = &(a->effects[j]);
/* check conditions
*/
for ( k = 0; k < e_->num_conditions; k++ ) {
for ( l = 0; l < e->num_conditions; l++ ) {
if ( e_->conditions[k] == e->conditions[l] ) {
break;
}
}
if ( l == e->num_conditions ) {
break;
}
}
if ( k < e_->num_conditions ) {
continue;
}
if ( e->num_conditions == e_->num_conditions ) {
same_effects[sn++] = j;
}
}
na = e->num_adds;
nd = e->num_dels;
for ( j = 0; j < sn; j++ ) {
na += a->effects[same_effects[j]].num_adds;
nd += a->effects[same_effects[j]].num_dels;
}
/*
* DEA - University of Brescia
*/
tmpnum = get_num_of_effects_of (n_ef, AT_END_TIME, 1);
// gef_conn[n_ef].A = (int *) calloc (na, sizeof (int));
gef_conn[n_ef].A = ( int * ) calloc( na + tmpnum, sizeof( int ) );
tmpnum = get_num_of_effects_of (n_ef, AT_START_TIME, 1);
if (tmpnum)
gef_conn[n_ef].sf->A_start = (int *) calloc (tmpnum, sizeof (int));
/*cancellanti */
tmpnum = get_num_of_effects_of (n_ef, AT_START_TIME, 0);
if (tmpnum)
gef_conn[n_ef].sf->D_start =(int *) calloc (tmpnum, sizeof (int));
/*
* End of DEA
*/
gef_conn[n_ef].D = ( int * ) calloc( nd, sizeof( int ) );
for ( j = 0; j < e->num_adds; j++ ) {
for ( k = 0; k < gef_conn[n_ef].num_A; k++ ) {
if ( gef_conn[n_ef].A[k] == e->adds[j] ) break;
}
if ( k < gef_conn[n_ef].num_A ) continue;
gef_conn[n_ef].A[gef_conn[n_ef].num_A++] = e->adds[j];
}
for ( j = 0; j < e->num_dels; j++ ) {
for ( k = 0; k < gef_conn[n_ef].num_D; k++ ) {
if ( gef_conn[n_ef].D[k] == e->dels[j] ) break;
}
if ( k < gef_conn[n_ef].num_D ) continue;
gef_conn[n_ef].D[gef_conn[n_ef].num_D++] = e->dels[j];
}
for ( j = 0; j < sn; j++ ) {
e_ = &(a->effects[same_effects[j]]);
for ( l = 0; l < e_->num_adds; l++ ) {
for ( k = 0; k < gef_conn[n_ef].num_A; k++ ) {
if ( gef_conn[n_ef].A[k] == e_->adds[l] ) break;
}
if ( k < gef_conn[n_ef].num_A ) continue;
gef_conn[n_ef].A[gef_conn[n_ef].num_A++] = e_->adds[l];
}
for ( l = 0; l < e_->num_dels; l++ ) {
for ( k = 0; k < gef_conn[n_ef].num_D; k++ ) {
if ( gef_conn[n_ef].D[k] == e_->dels[l] ) break;
}
if ( k < gef_conn[n_ef].num_D ) continue;
gef_conn[n_ef].D[gef_conn[n_ef].num_D++] = e_->dels[l];
}
}
a->effects[i].ef_conn_pos = n_ef;
for ( j = 0; j < sn; j++ ) {
had_effects[same_effects[j]] = TRUE;
a->effects[same_effects[j]].ef_conn_pos = n_ef;
}
/*
* DEA - University of Brescia
*/
tmpnum = get_num_of_preconds_of(n_ef,AT_START_TIME);
// gef_conn[n_ef].PC = (int *) calloc (e->num_conditions + a->num_preconds, sizeof (int));
gef_conn[n_ef].PC = ( int * ) calloc( e->num_conditions + a->num_preconds + tmpnum, sizeof( int ) );
/*alloco lo spazio anche per le condizioni overall */
tmpnum = get_num_of_preconds_of (n_ef, OVER_ALL_TIME);
if (tmpnum)
gef_conn[n_ef].sf->PC_overall = (int *) calloc (tmpnum, sizeof (int));
/*alloco lo spazio anche per le condizioni at end */
tmpnum = get_num_of_preconds_of (n_ef, AT_END_TIME);
if (tmpnum)
gef_conn[n_ef].sf->PC_end = (int *) calloc (tmpnum, sizeof (int));
/*
* End of DEA
*/
for ( j = 0; j < a->num_preconds; j++ ) {
for ( k = 0; k < gef_conn[n_ef].num_PC; k++ ) {
if ( gef_conn[n_ef].PC[k] == a->preconds[j] ) break;
}
if ( k < gef_conn[n_ef].num_PC ) continue;
gef_conn[n_ef].PC[gef_conn[n_ef].num_PC++] = a->preconds[j];
}
for ( j = 0; j < e->num_conditions; j++ ) {
for ( k = 0; k < gef_conn[n_ef].num_PC; k++ ) {
if ( gef_conn[n_ef].PC[k] == e->conditions[j] ) break;
}
if ( k < gef_conn[n_ef].num_PC ) continue;
gef_conn[n_ef].PC[gef_conn[n_ef].num_PC++] = e->conditions[j];
}
n_ef++;
gnum_ef_conn++;
}/* ende all a->effects */
/* setup implied effects info
*/
if ( a->num_effects > 1 ) {
m = 0;
for ( i = a->effects[0].ef_conn_pos; i < n_ef - 1; i++ ) {
for ( j = i+1; j < n_ef; j++ ) {
/* i ==> j ? */
for ( k = 0; k < gef_conn[j].num_PC; k++ ) {
for ( l = 0; l < gef_conn[i].num_PC; l++ ) {
if ( gef_conn[i].PC[l] == gef_conn[j].PC[k] ) break;
}
if ( l == gef_conn[i].num_PC ) break;
}
if ( k == gef_conn[j].num_PC ) {
gef_conn[i].num_I++;
}
/* j ==> i ? */
for ( k = 0; k < gef_conn[i].num_PC; k++ ) {
for ( l = 0; l < gef_conn[j].num_PC; l++ ) {
if ( gef_conn[j].PC[l] == gef_conn[i].PC[k] ) break;
}
if ( l == gef_conn[j].num_PC ) break;
}
if ( k == gef_conn[i].num_PC ) {
gef_conn[j].num_I++;
}
}
}
for ( i = a->effects[0].ef_conn_pos; i < n_ef; i++ ) {
gef_conn[i].I = ( int * ) calloc( gef_conn[i].num_I, sizeof( int ) );
gef_conn[i].num_I = 0;
}
for ( i = a->effects[0].ef_conn_pos; i < n_ef - 1; i++ ) {
for ( j = i+1; j < n_ef; j++ ) {
/* i ==> j ? */
for ( k = 0; k < gef_conn[j].num_PC; k++ ) {
for ( l = 0; l < gef_conn[i].num_PC; l++ ) {
if ( gef_conn[i].PC[l] == gef_conn[j].PC[k] ) break;
}
if ( l == gef_conn[i].num_PC ) break;
}
if ( k == gef_conn[j].num_PC ) {
gef_conn[i].I[gef_conn[i].num_I++] = j;
}
/* j ==> i ? */
for ( k = 0; k < gef_conn[i].num_PC; k++ ) {
for ( l = 0; l < gef_conn[j].num_PC; l++ ) {
if ( gef_conn[j].PC[l] == gef_conn[i].PC[k] ) break;
}
if ( l == gef_conn[j].num_PC ) break;
}
if ( k == gef_conn[i].num_PC ) {
gef_conn[j].I[gef_conn[j].num_I++] = i;
}
}
}
}
/* first sweep: only count the space we need for the fact arrays !
*/
if ( a->num_effects > 0 ) {
for ( i = a->effects[0].ef_conn_pos; i < n_ef; i++ ) {
for ( j = 0; j < gef_conn[i].num_PC; j++ ) {
gft_conn[gef_conn[i].PC[j]].num_PC++;
}
for ( j = 0; j < gef_conn[i].num_A; j++ ) {
gft_conn[gef_conn[i].A[j]].num_A++;
}
for ( j = 0; j < gef_conn[i].num_D; j++ ) {
gft_conn[gef_conn[i].D[j]].num_D++;
}
}
}
n_op++;
}
for ( i = 0; i < gnum_ft_conn; i++ ) {
gft_conn[i].PC = ( int * ) calloc( gft_conn[i].num_PC, sizeof( int ) );
gft_conn[i].num_PC = 0;
gft_conn[i].A = ( int * ) calloc( gft_conn[i].num_A, sizeof( int ) );
gft_conn[i].num_A = 0;
gft_conn[i].D = ( int * ) calloc( gft_conn[i].num_D, sizeof( int ) );
gft_conn[i].num_D = 0;
gft_conn[i].is_global_goal = FALSE;
}
for ( i = 0; i < ggoal_state.num_F; i++ ) {
gft_conn[ggoal_state.F[i]].is_global_goal = TRUE;
}
for ( i = 0; i < gnum_ef_conn; i++ ) {
for ( j = 0; j < gef_conn[i].num_PC; j++ ) {
gft_conn[gef_conn[i].PC[j]].PC[gft_conn[gef_conn[i].PC[j]].num_PC++] = i;
}
for ( j = 0; j < gef_conn[i].num_A; j++ ) {
gft_conn[gef_conn[i].A[j]].A[gft_conn[gef_conn[i].A[j]].num_A++] = i;
}
for ( j = 0; j < gef_conn[i].num_D; j++ ) {
gft_conn[gef_conn[i].D[j]].D[gft_conn[gef_conn[i].D[j]].num_D++] = i;
}
}
free( same_effects );
free( had_effects );
if ( gcmd_line.display_info == 121) {
printf("\n\ncreated connectivity graph as follows:");
printf("\n\n------------------OP ARRAY:-----------------------");
for ( i = 0; i < gnum_op_conn; i++ ) {
/*
* DEA - University of Brescia
*/
sizeofgop += sizeof (gop_conn[i]) + sizeof (int) * (gop_conn[i].num_E - 1);
/*
* End of DEA
*/
printf("\n\nOP: ");
print_op_name( i );
printf("\n----------EFFS:");
for ( j = 0; j < gop_conn[i].num_E; j++ ) {
printf("\neffect %d", gop_conn[i].E[j]);
}
/*
* DEA - University of Brescia
*/
printf ("\nSIZE = %d", sizeof (gop_conn[i]) + sizeof (int) * (gop_conn[i].num_E - 1));
/*
* End of DEA
*/
}
printf("\n\n-------------------EFFECT ARRAY:----------------------");
for ( i = 0; i < gnum_ef_conn; i++ ) {
/*
* DEA - University of Brescia
*/
sizeofgef += sizeof (gef_conn[i]) + sizeof (int) * (gef_conn[i].num_PC - 1) +
sizeof (int) * (gef_conn[i].num_A - 1) + sizeof (int) * (gef_conn[i].num_D - 1);
/*
* End of DEA
*/
printf("\n\neffect %d of op %d: ", i, gef_conn[i].op);
print_op_name( gef_conn[i].op );
printf("\n----------PCS:");
for ( j = 0; j < gef_conn[i].num_PC; j++ ) {
printf("\n");
print_ft_name( gef_conn[i].PC[j] );
}
printf("\n----------ADDS:");
for ( j = 0; j < gef_conn[i].num_A; j++ ) {
printf("\n");
print_ft_name( gef_conn[i].A[j] );
}
printf("\n----------DELS:");
for ( j = 0; j < gef_conn[i].num_D; j++ ) {
printf("\n");
print_ft_name( gef_conn[i].D[j] );
}
printf("\n----------IMPLIEDS:");
for ( j = 0; j < gef_conn[i].num_I; j++ ) {
printf("\nimplied effect %d of op %d: ",
gef_conn[i].I[j], gef_conn[gef_conn[i].I[j]].op);
print_op_name( gef_conn[gef_conn[i].I[j]].op );
}
}
printf("\n\n----------------------FT ARRAY:-----------------------------");
for ( i = 0; i < gnum_ft_conn; i++ ) {
/*
* DEA - University of Brescia
*/
sizeofgft += sizeof (gft_conn[i]) + sizeof (int) * (gft_conn[i].num_PC - 1) +
sizeof (int) * (gft_conn[i].num_A - 1) + sizeof (int) * (gft_conn[i].num_D - 1);
// printf("\n\nFT: ");
printf ("\n ----------------- \n\n %d FT: ", i);
/*
* End of DEA
*/
print_ft_name( i );
printf(" rand: %d", gft_conn[i].rand);
printf("\n----------PRE COND OF:");
for ( j = 0; j < gft_conn[i].num_PC; j++ ) {
printf("\neffect %d", gft_conn[i].PC[j]);
}
printf("\n----------ADD BY:");
for ( j = 0; j < gft_conn[i].num_A; j++ ) {
printf("\neffect %d", gft_conn[i].A[j]);
}
printf("\n----------DEL BY:");
for ( j = 0; j < gft_conn[i].num_D; j++ ) {
printf("\neffect %d", gft_conn[i].D[j]);
}
/*
* DEA - University of Brescia
*/
printf ("\nSIZE= %d", sizeof (gft_conn[i]) + sizeof (int) * (gft_conn[i].num_PC - 1) +
sizeof (int) * (gft_conn[i].num_A - 1) + sizeof (int) * (gft_conn[i].num_D - 1));
/*
* End of DEA
*/
}
}
/*
* DEA - University of Brescia
*/
gnum_ef_block = gnum_ef_conn / 32 + 1;
for (i = 0; i < gnum_ft_conn; i++)
gft_conn[i].position = i;
for (i = 0; i < gnum_ef_conn; i++)
gef_conn[i].position = i;
if (DEBUG0)
{
// printf ("Number of actions : %7d", gnum_ef_conn);
// printf ("\nNumber of facts : %7d", gnum_ft_conn);
// fflush(stdout);
}
if (gcmd_line.display_info == 121)
{
printf ("\nDim. azioni (gop_conn): %7d", sizeofgop);
printf ("\nDim. 'effetti' (gef_conn): %7d", sizeofgef);
printf ("\nDim. fatti (gft_conn): %7d", sizeofgft);
}
/*
* End of DEA
*/
}
void build_connectivity_graph( void )
{
int i, j, n;
Action *a;
struct timeb tp;
ftime( &tp );
srandom( tp.millitm );
gnum_ft_conn = gnum_relevant_facts;
gnum_op_conn = gnum_actions;
gft_conn = ( FtConn * ) calloc( gnum_ft_conn, sizeof( FtConn ) );
gop_conn = ( OpConn * ) calloc( gnum_op_conn, sizeof( OpConn ) );
for ( i = 0; i < gnum_ft_conn; i++ ) {
gft_conn[i].num_P = 0;
gft_conn[i].num_A = 0;
gft_conn[i].num_D = 0;
gft_conn[i].rand = random() % STATE_HASH_SIZE;
}
for ( i = 0; i < gnum_op_conn; i++ ) {
gop_conn[i].num_P = 0;
gop_conn[i].num_A = 0;
gop_conn[i].num_D = 0;
}
n = 0;
for ( a = gactions; a; a = a->next ) {
/* ops are simply copied over. a waste of time and memory,
* but, usually there are not so many actions after
* the fixpoint. can speed that up for optimization, but
* keep it the clean and tidy way for the time being.
*/
gop_conn[n].op = a->op;
for ( i = 0; i < goperators[a->op]->num_vars; i++ ) {
gop_conn[n].inst_table[i] = a->inst_table[i];
}
gop_conn[n].P = ( int * ) calloc( a->num_preconds, sizeof( int ) );
for ( i = 0; i < a->num_preconds; i++ ) {
gop_conn[n].P[i] = a->preconds[i];
}
gop_conn[n].num_P = a->num_preconds;
gop_conn[n].A = ( int * ) calloc( a->num_adds, sizeof( int ) );
for ( i = 0; i < a->num_adds; i++ ) {
gop_conn[n].A[i] = a->adds[i];
}
gop_conn[n].num_A = a->num_adds;
gop_conn[n].D = ( int * ) calloc( a->num_dels, sizeof( int ) );
for ( i = 0; i < a->num_dels; i++ ) {
gop_conn[n].D[i] = a->dels[i];
}
gop_conn[n].num_D = a->num_dels;
/* first sweep: only count the space we need for the fact arrays !
*/
for ( i = 0; i < a->num_preconds; i++ ) {
gft_conn[a->preconds[i]].num_P++;
}
for ( i = 0; i < a->num_adds; i++ ) {
gft_conn[a->adds[i]].num_A++;
}
for ( i = 0; i < a->num_dels; i++ ) {
gft_conn[a->dels[i]].num_D++;
}
n++;
}
for ( i = 0; i < gnum_ft_conn; i++ ) {
gft_conn[i].P = ( int * ) calloc( gft_conn[i].num_P, sizeof( int ) );
gft_conn[i].num_P = 0;
gft_conn[i].A = ( int * ) calloc( gft_conn[i].num_A, sizeof( int ) );
gft_conn[i].num_A = 0;
gft_conn[i].D = ( int * ) calloc( gft_conn[i].num_D, sizeof( int ) );
gft_conn[i].num_D = 0;
}
n = 0;
for ( a = gactions; a; a = a->next ) {
/* second sweep: now put the op numbers into the arrays
*/
for ( i = 0; i < a->num_preconds; i++ ) {
gft_conn[a->preconds[i]].P[gft_conn[a->preconds[i]].num_P++] = n;
}
for ( i = 0; i < a->num_adds; i++ ) {
gft_conn[a->adds[i]].A[gft_conn[a->adds[i]].num_A++] = n;
}
for ( i = 0; i < a->num_dels; i++ ) {
gft_conn[a->dels[i]].D[gft_conn[a->dels[i]].num_D++] = n;
}
n++;
}
if ( gcmd_line.display_info == 111 ) {
printf("\n\ncreated connectivity graph as follows:");
printf("\n\nOP ARRAY:");
for ( i = 0; i < gnum_op_conn; i++ ) {
printf("\n\nOP: ");
print_op_name( i );
printf("\n----------PRES:");
for ( j = 0; j < gop_conn[i].num_P; j++ ) {
printf("\n");
print_ft_name( gop_conn[i].P[j] );
}
printf("\n----------ADDS:");
for ( j = 0; j < gop_conn[i].num_A; j++ ) {
printf("\n");
print_ft_name( gop_conn[i].A[j] );
}
printf("\n----------DELS:");
for ( j = 0; j < gop_conn[i].num_D; j++ ) {
printf("\n");
print_ft_name( gop_conn[i].D[j] );
}
}
printf("\n\nFT ARRAY:");
for ( i = 0; i < gnum_ft_conn; i++ ) {
printf("\n\nFT: ");
print_ft_name( i );
printf("\n----------PRE OF:");
for ( j = 0; j < gft_conn[i].num_P; j++ ) {
printf("\n");
print_op_name( gft_conn[i].P[j] );
}
printf("\n----------ADD BY:");
for ( j = 0; j < gft_conn[i].num_A; j++ ) {
printf("\n");
print_op_name( gft_conn[i].A[j] );
}
printf("\n----------DEL BY:");
for ( j = 0; j < gft_conn[i].num_D; j++ ) {
printf("\n");
print_op_name( gft_conn[i].D[j] );
}
}
}
}
void collect_relevant_facts( void )
{
Action *a;
Operator *o;
int i, j, adr;
/* mark all deleted facts; such facts, that are also pos, are relevant.
*/
for ( a = gactions; a; a = a->next ) {
o = goperators[a->op];
for ( i = 0; i < o->num_dels; i++ ) {
lp = o->dels[i].predicate;
for ( j = 0; j < garity[lp]; j++ ) {
largs[j] = GET_CONSTANT( o->dels[i].args[j], a );
}
adr = fact_adress();
lneg[lp][adr] = 1;
if ( lpos[lp][adr] &&
!luse[lp][adr] ) {
luse[lp][adr] = 1;
lindex[lp][adr] = gnum_relevant_facts;
if ( gnum_relevant_facts == MAX_RELEVANT_FACTS ) {
printf("\nincrease MAX_RELEVANT_FACTS! (current value: %d)\n\n",
MAX_RELEVANT_FACTS);
exit( 1 );
}
grelevant_facts[gnum_relevant_facts].predicate = lp;
for ( j = 0; j < garity[lp]; j++ ) {
grelevant_facts[gnum_relevant_facts].args[j] = largs[j];
}
lindex[lp][adr] = gnum_relevant_facts;
gnum_relevant_facts++;
}
}
}
/* now build final action instances
*/
for ( a = gactions; a; a = a->next ) {
o = goperators[a->op];
for ( i = 0; i < o->num_preconds; i++ ) {
lp = o->preconds[i].predicate;
for ( j = 0; j < garity[lp]; j++ ) {
largs[j] = GET_CONSTANT( o->preconds[i].args[j], a );
}
adr = fact_adress();
if ( !lneg[lp][adr] ) {
continue;
}
a->preconds[a->num_preconds++] = lindex[lp][adr];
}
for ( i = 0; i < o->num_adds; i++ ) {
lp = o->adds[i].predicate;
for ( j = 0; j < garity[lp]; j++ ) {
largs[j] = GET_CONSTANT( o->adds[i].args[j], a );
}
adr = fact_adress();
if ( !lneg[lp][adr] ) {
continue;
}
a->adds[a->num_adds++] = lindex[lp][adr];
}
for ( i = 0; i < o->num_dels; i++ ) {
lp = o->dels[i].predicate;
for ( j = 0; j < garity[lp]; j++ ) {
largs[j] = GET_CONSTANT( o->dels[i].args[j], a );
}
adr = fact_adress();
if ( !lpos[lp][adr] ) {
continue;
}
a->dels[a->num_dels++] = lindex[lp][adr];
}
}
/* build final initial and goal representation
*/
ginitial_state.num_F = 0;
for ( i = 0; i < gnum_initial; i++ ) {
lp = ginitial[i].predicate;
for ( j = 0; j < garity[lp]; j++ ) {
largs[j] = ginitial[i].args[j];
}
adr = fact_adress();
if ( !lneg[lp][adr] ) {
continue;
}
ginitial_state.F[ginitial_state.num_F++] = lindex[lp][adr];
}
ggoal_state.num_F = 0;
for ( i = 0; i < gnum_goal; i++ ) {
lp = ggoal[i].predicate;
for ( j = 0; j < garity[lp]; j++ ) {
largs[j] = ggoal[i].args[j];
}
adr = fact_adress();
if ( !lneg[lp][adr] ) {
continue;
}
ggoal_state.F[ggoal_state.num_F++] = lindex[lp][adr];
}
if ( gcmd_line.display_info == 110 ) {
printf("\n\nfinal domain representation:");
printf("\n\nall actions:");
for ( a = gactions; a; a = a->next ) {
print_Action( a );
}
printf("\n\ninitial_state:");
for ( i = 0; i < ginitial_state.num_F; i++ ) {
printf("\n");
print_ft_name( ginitial_state.F[i] );
}
printf("\n\ngoal_state:");
for ( i = 0; i < ggoal_state.num_F; i++ ) {
printf("\n");
print_ft_name( ggoal_state.F[i] );
}
}
}
void print_lnf_Action( Action *a )
{
ActionEffect *e;
int i, j;
if ( !a->norm_operator &&
!a->pseudo_action ) {
printf("\n\nAction REACH-GOAL");
} else {
printf("\n\nAction %s", a->name );
for ( i = 0; i < a->num_name_vars; i++ ) {
printf(" %s", gconstants[a->name_inst_table[i]]);
}
}
printf("\n\nPreconds:\n");
for ( i = 0; i < a->num_preconds; i++ ) {
print_ft_name( a->preconds[i] );
printf("\n");
}
for ( i = 0; i < a->num_lnf_preconds; i++ ) {
switch ( a->lnf_preconds_comp[i] ) {
case GEQ:
printf("(>= ");
break;
case GE:
printf("(> ");
break;
default:
printf("\nwrong comparator of Expnodes in lnf actionpre %d\n\n",
a->lnf_preconds_comp[i]);
exit( 1 );
}
print_LnfExpNode( a->lnf_preconds_lh[i] );
printf(" %.2f)\n", a->lnf_preconds_rh[i]);
}
printf("\n\nEffects:");
for ( j = 0; j < a->num_effects; j++ ) {
printf("\n\neffect %d COST %f", j, a->effects[j].cost);
e = &(a->effects[j]);
if ( e->illegal ) printf(" ILLEGAL EFFECT!");
if ( e->removed ) printf(" REMOVED!!!");
printf("\n\nConditions\n");
for ( i = 0; i < e->num_conditions; i++ ) {
print_ft_name( e->conditions[i] );
printf("\n");
}
for ( i = 0; i < e->num_lnf_conditions; i++ ) {
switch ( e->lnf_conditions_comp[i] ) {
case GEQ:
printf("(>= ");
break;
case GE:
printf("(> ");
break;
default:
printf("\nwrong comparator of Expnodes in lnf normeff %d\n\n",
e->lnf_conditions_comp[i]);
exit( 1 );
}
print_LnfExpNode( e->lnf_conditions_lh[i] );
printf(" %.2f)\n", e->lnf_conditions_rh[i] );
}
printf("\nAdds\n");
for ( i = 0; i < e->num_adds; i++ ) {
print_ft_name( e->adds[i] );
printf("\n");
}
printf("\nDels\n");
for ( i = 0; i < e->num_dels; i++ ) {
print_ft_name( e->dels[i] );
printf("\n");
}
for ( i = 0; i < e->num_lnf_effects; i++ ) {
switch ( e->lnf_effects_neft[i] ) {
case ASSIGN:
printf("\nassign ");
break;
case INCREASE:
printf("\nincrease ");
break;
default:
printf("\n\nprint lnf normop: illegal neft %d\n\n",
e->lnf_effects_neft[i]);
exit( 1 );
}
if ( e->lnf_effects_fl[i] >= 0 ) {
print_fl_name( e->lnf_effects_fl[i] );
} else {
printf("[UNDEF]");
}
print_LnfExpNode( e->lnf_effects_rh[i] );
}
}
}
void build_connectivity_graph( void )
{
int i, j, k, l, n_op, n_ef, na, nd, ef, ef_, m, l_;
Action *a;
int *same_effects, sn;
Bool *had_effects;
ActionEffect *e, *e_, *e__;
struct timeb tp;
ftime( &tp );
srandom( tp.millitm );
gnum_ft_conn = gnum_relevant_facts;
gnum_op_conn = gnum_actions;
gft_conn = ( FtConn * ) calloc( gnum_ft_conn, sizeof( FtConn ) );
gop_conn = ( OpConn * ) calloc( gnum_op_conn, sizeof( OpConn ) );
gef_conn = ( EfConn * ) calloc( lnum_effects, sizeof( EfConn ) );
gnum_ef_conn = 0;
same_effects = ( int * ) calloc( lnum_effects, sizeof( int ) );
had_effects = ( Bool * ) calloc( lnum_effects, sizeof( Bool ) );
for ( i = 0; i < gnum_ft_conn; i++ ) {
gft_conn[i].num_PC = 0;
gft_conn[i].num_A = 0;
gft_conn[i].num_D = 0;
gft_conn[i].rand = random() % BIG_INT;
}
for ( i = 0; i < gnum_op_conn; i++ ) {
gop_conn[i].num_E = 0;
}
for ( i = 0; i < lnum_effects; i++ ) {
gef_conn[i].num_PC = 0;
gef_conn[i].num_A = 0;
gef_conn[i].num_D = 0;
gef_conn[i].num_I = 0;
gef_conn[i].removed = FALSE;
}
n_op = 0;
n_ef = 0;
for ( a = gactions; a; a = a->next ) {
gop_conn[n_op].action = a;
gop_conn[n_op].E = ( int * ) calloc( a->num_effects, sizeof( int ) );
for ( i = 0; i < a->num_effects; i++ ) {
had_effects[i] = FALSE;
}
for ( i = 0; i < a->num_effects; i++ ) {
if ( had_effects[i] ) {
continue;
}
had_effects[i] = TRUE;
e = &(a->effects[i]);
gop_conn[n_op].E[gop_conn[n_op].num_E++] = n_ef;
gef_conn[n_ef].op = n_op;
gef_conn[n_ef].PC = ( int * )
calloc( e->num_conditions + a->num_preconds, sizeof( int ) );
for ( j = 0; j < a->num_preconds; j++ ) {
for ( k = 0; k < gef_conn[n_ef].num_PC; k++ ) {
if ( gef_conn[n_ef].PC[k] == a->preconds[j] ) break;
}
if ( k < gef_conn[n_ef].num_PC ) continue;
gef_conn[n_ef].PC[gef_conn[n_ef].num_PC++] = a->preconds[j];
}
for ( j = 0; j < e->num_conditions; j++ ) {
for ( k = 0; k < gef_conn[n_ef].num_PC; k++ ) {
if ( gef_conn[n_ef].PC[k] == e->conditions[j] ) break;
}
if ( k < gef_conn[n_ef].num_PC ) continue;
gef_conn[n_ef].PC[gef_conn[n_ef].num_PC++] = e->conditions[j];
}
sn = 0;
for ( j = i + 1; j < a->num_effects; j++ ) {
if ( had_effects[j] ) {
continue;
}
e_ = &(a->effects[j]);
/* check conditions
*/
for ( k = 0; k < e_->num_conditions; k++ ) {
for ( l = 0; l < e->num_conditions; l++ ) {
if ( e_->conditions[k] == e->conditions[l] ) {
break;
}
}
if ( l == e->num_conditions ) {
break;
}
}
if ( k < e_->num_conditions ) {
continue;
}
if ( e->num_conditions == e_->num_conditions ) {
same_effects[sn++] = j;
}
}
na = e->num_adds;
nd = e->num_dels;
for ( j = 0; j < sn; j++ ) {
na += a->effects[same_effects[j]].num_adds;
nd += a->effects[same_effects[j]].num_dels;
}
gef_conn[n_ef].A = ( int * ) calloc( na, sizeof( int ) );
gef_conn[n_ef].D = ( int * ) calloc( nd, sizeof( int ) );
for ( j = 0; j < e->num_adds; j++ ) {
for ( k = 0; k < gef_conn[n_ef].num_A; k++ ) {
if ( gef_conn[n_ef].A[k] == e->adds[j] ) break;
}
if ( k < gef_conn[n_ef].num_A ) continue;
/* exclude already true adds
*/
for ( k = 0; k < gef_conn[n_ef].num_PC; k++ ) {
if ( gef_conn[n_ef].PC[k] == e->adds[j] ) break;
}
if ( k < gef_conn[n_ef].num_PC ) continue;
gef_conn[n_ef].A[gef_conn[n_ef].num_A++] = e->adds[j];
}
for ( j = 0; j < e->num_dels; j++ ) {
for ( k = 0; k < gef_conn[n_ef].num_D; k++ ) {
if ( gef_conn[n_ef].D[k] == e->dels[j] ) break;
}
if ( k < gef_conn[n_ef].num_D ) continue;
/* exclude re-added dels; check against *all*
* adds to be integrated.
*/
for ( k = 0; k < e->num_adds; k++ ) {
if ( e->adds[k] == e->dels[j] ) break;
}
if ( k < e->num_adds ) continue;
for ( l = 0; l < sn; l++ ) {
e_ = &(a->effects[same_effects[l]]);
for ( k = 0; k < e_->num_adds; k++ ) {
if ( e_->adds[k] == e->dels[j] ) break;
}
if ( k < e_->num_adds ) break;
}
if ( l < sn ) continue;
gef_conn[n_ef].D[gef_conn[n_ef].num_D++] = e->dels[j];
}
for ( j = 0; j < sn; j++ ) {
e_ = &(a->effects[same_effects[j]]);
for ( l = 0; l < e_->num_adds; l++ ) {
for ( k = 0; k < gef_conn[n_ef].num_A; k++ ) {
if ( gef_conn[n_ef].A[k] == e_->adds[l] ) break;
}
if ( k < gef_conn[n_ef].num_A ) continue;
for ( k = 0; k < gef_conn[n_ef].num_PC; k++ ) {
if ( gef_conn[n_ef].PC[k] == e_->adds[l] ) break;
}
if ( k < gef_conn[n_ef].num_PC ) continue;
gef_conn[n_ef].A[gef_conn[n_ef].num_A++] = e_->adds[l];
}
for ( l = 0; l < e_->num_dels; l++ ) {
for ( k = 0; k < gef_conn[n_ef].num_D; k++ ) {
if ( gef_conn[n_ef].D[k] == e_->dels[l] ) break;
}
if ( k < gef_conn[n_ef].num_D ) continue;
/* exclude re-added dels; check against *all*
* adds to be integrated.
*/
for ( k = 0; k < e->num_adds; k++ ) {
if ( e->adds[k] == e_->dels[l] ) break;
}
if ( k < e->num_adds ) continue;
for ( l_ = 0; l_ < sn; l_++ ) {
e__ = &(a->effects[same_effects[l_]]);
for ( k = 0; k < e__->num_adds; k++ ) {
if ( e__->adds[k] == e_->dels[l] ) break;
}
if ( k < e__->num_adds ) break;
}
if ( l_ < sn ) continue;
gef_conn[n_ef].D[gef_conn[n_ef].num_D++] = e_->dels[l];
}
}
for ( j = 0; j < sn; j++ ) {
had_effects[same_effects[j]] = TRUE;
}
n_ef++;
gnum_ef_conn++;
}/* ende all a->effects */
if ( gop_conn[n_op].num_E >= 1 ) {
/* CHECK EMPTY EFFECTS!
*
* two step process --- first, remove all effects that are entirely empty.
* second, check if all remaining effects are illegal
* or only delete:
* in that case, the op will never do any good so we
* remove all its effects.
*/
i = 0;
while ( i < gop_conn[n_op].num_E ) {
if ( gef_conn[gop_conn[n_op].E[i]].num_A != 0 ||
gef_conn[gop_conn[n_op].E[i]].num_D != 0 ) {
i++;
continue;
}
/* we keep it in the gef_conn (seems easier),
* but mark it as removed, which will exclude it from everything.
*/
gef_conn[gop_conn[n_op].E[i]].removed = TRUE;
for ( j = i; j < gop_conn[n_op].num_E - 1; j++ ) {
gop_conn[n_op].E[j] = gop_conn[n_op].E[j+1];
}
gop_conn[n_op].num_E--;
}
m = 0;
for ( i = 0; i < gop_conn[n_op].num_E; i++ ) {
if ( gef_conn[gop_conn[n_op].E[i]].num_A == 0 ) {
m++;
}
}
if ( m == gop_conn[n_op].num_E ) {
/* all remaining effects solely-deleters.
*/
for ( i = 0; i < gop_conn[n_op].num_E; i++ ) {
gef_conn[gop_conn[n_op].E[i]].removed = TRUE;
}
gop_conn[n_op].num_E = 0;
}
}
/* setup implied effects info
*/
if ( gop_conn[n_op].num_E > 1 ) {
for ( i = 0; i < gop_conn[n_op].num_E; i++ ) {
ef = gop_conn[n_op].E[i];
gef_conn[ef].I = ( int * ) calloc( gop_conn[n_op].num_E, sizeof( int ) );
gef_conn[ef].num_I = 0;
}
for ( i = 0; i < gop_conn[n_op].num_E - 1; i++ ) {
ef = gop_conn[n_op].E[i];
for ( j = i+1; j < gop_conn[n_op].num_E; j++ ) {
ef_ = gop_conn[n_op].E[j];
/* ef ==> ef_ ? */
for ( k = 0; k < gef_conn[ef_].num_PC; k++ ) {
for ( l = 0; l < gef_conn[ef].num_PC; l++ ) {
if ( gef_conn[ef].PC[l] == gef_conn[ef_].PC[k] ) break;
}
if ( l == gef_conn[ef].num_PC ) break;
}
if ( k == gef_conn[ef_].num_PC ) {
gef_conn[ef].I[gef_conn[ef].num_I++] = ef_;
}
/* j ==> i ? */
for ( k = 0; k < gef_conn[ef].num_PC; k++ ) {
for ( l = 0; l < gef_conn[ef_].num_PC; l++ ) {
if ( gef_conn[ef_].PC[l] == gef_conn[ef].PC[k] ) break;
}
if ( l == gef_conn[ef_].num_PC ) break;
}
if ( k == gef_conn[ef].num_PC ) {
gef_conn[ef_].I[gef_conn[ef_].num_I++] = ef;
}
}
}
}
/* first sweep: only count the space we need for the fact arrays !
*/
if ( gop_conn[n_op].num_E > 0 ) {
for ( i = 0; i < gop_conn[n_op].num_E; i++ ) {
ef = gop_conn[n_op].E[i];
for ( j = 0; j < gef_conn[ef].num_PC; j++ ) {
gft_conn[gef_conn[ef].PC[j]].num_PC++;
}
for ( j = 0; j < gef_conn[ef].num_A; j++ ) {
gft_conn[gef_conn[ef].A[j]].num_A++;
}
for ( j = 0; j < gef_conn[ef].num_D; j++ ) {
gft_conn[gef_conn[ef].D[j]].num_D++;
}
}
}
n_op++;
}
for ( i = 0; i < gnum_ft_conn; i++ ) {
if ( gft_conn[i].num_PC > 0 ) {
gft_conn[i].PC = ( int * ) calloc( gft_conn[i].num_PC, sizeof( int ) );
}
gft_conn[i].num_PC = 0;
if ( gft_conn[i].num_A > 0 ) {
gft_conn[i].A = ( int * ) calloc( gft_conn[i].num_A, sizeof( int ) );
}
gft_conn[i].num_A = 0;
if ( gft_conn[i].num_D > 0 ) {
gft_conn[i].D = ( int * ) calloc( gft_conn[i].num_D, sizeof( int ) );
}
gft_conn[i].num_D = 0;
gft_conn[i].is_global_goal = FALSE;
}
for ( i = 0; i < ggoal_state.num_F; i++ ) {
gft_conn[ggoal_state.F[i]].is_global_goal = TRUE;
}
for ( i = 0; i < gnum_ef_conn; i++ ) {
if ( gef_conn[i].removed ) continue;
for ( j = 0; j < gef_conn[i].num_PC; j++ ) {
gft_conn[gef_conn[i].PC[j]].PC[gft_conn[gef_conn[i].PC[j]].num_PC++] = i;
}
for ( j = 0; j < gef_conn[i].num_A; j++ ) {
gft_conn[gef_conn[i].A[j]].A[gft_conn[gef_conn[i].A[j]].num_A++] = i;
}
for ( j = 0; j < gef_conn[i].num_D; j++ ) {
gft_conn[gef_conn[i].D[j]].D[gft_conn[gef_conn[i].D[j]].num_D++] = i;
}
}
free( same_effects );
free( had_effects );
if ( gcmd_line.display_info == 121 ) {
printf("\n\ncreated connectivity graph as follows:");
printf("\n\n------------------OP ARRAY:-----------------------");
for ( i = 0; i < gnum_op_conn; i++ ) {
printf("\n\nOP: ");
print_op_name( i );
printf("\n----------EFFS:");
for ( j = 0; j < gop_conn[i].num_E; j++ ) {
printf("\neffect %d", gop_conn[i].E[j]);
}
}
printf("\n\n-------------------EFFECT ARRAY:----------------------");
for ( i = 0; i < gnum_ef_conn; i++ ) {
printf("\n\neffect %d of op %d: ", i, gef_conn[i].op);
print_op_name( gef_conn[i].op );
if ( gef_conn[i].removed ) {
printf(" --- REMOVED ");
continue;
}
printf("\n----------PCS:");
for ( j = 0; j < gef_conn[i].num_PC; j++ ) {
printf("\n");
print_ft_name( gef_conn[i].PC[j] );
}
printf("\n----------ADDS:");
for ( j = 0; j < gef_conn[i].num_A; j++ ) {
printf("\n");
print_ft_name( gef_conn[i].A[j] );
}
printf("\n----------DELS:");
for ( j = 0; j < gef_conn[i].num_D; j++ ) {
printf("\n");
print_ft_name( gef_conn[i].D[j] );
}
printf("\n----------IMPLIEDS:");
for ( j = 0; j < gef_conn[i].num_I; j++ ) {
printf("\nimplied effect %d of op %d: ",
gef_conn[i].I[j], gef_conn[gef_conn[i].I[j]].op);
print_op_name( gef_conn[gef_conn[i].I[j]].op );
}
}
printf("\n\n----------------------FT ARRAY:-----------------------------");
for ( i = 0; i < gnum_ft_conn; i++ ) {
printf("\n\nFT: ");
print_ft_name( i );
printf(" rand: %d", gft_conn[i].rand);
printf("\n----------PRE COND OF:");
for ( j = 0; j < gft_conn[i].num_PC; j++ ) {
printf("\neffect %d", gft_conn[i].PC[j]);
}
printf("\n----------ADD BY:");
for ( j = 0; j < gft_conn[i].num_A; j++ ) {
printf("\neffect %d", gft_conn[i].A[j]);
}
printf("\n----------DEL BY:");
for ( j = 0; j < gft_conn[i].num_D; j++ ) {
printf("\neffect %d", gft_conn[i].D[j]);
}
}
}
}
int main (int argc, char *argv[])
{
/* resulting name for ops file */
char ops_file[MAX_LENGTH] = "";
/* same for fct file */
char fct_file[MAX_LENGTH] = "";
char sol_file[MAX_LENGTH] = "";
struct tms start, end;
struct timeval tv;
struct timezone tz;
State current_start, current_end;
int i, j, k;
Bool found_plan=0;
#ifdef __EFENCE__
extern int EF_ALLOW_MALLOC_0;
EF_ALLOW_MALLOC_0 = 1;
#endif
printf("#\n");
printf("# (C) Copyright 2008, University of Illinois, Urbana-Champaign\n");
printf("#\n");
printf("# All rights reserved. Use of this software is permitted ONLY for\n");
printf("# non-commercial research purposes, and it may be copied only\n");
printf("# for that use only. All copies must include this copyright message.\n");
printf("# This software is made available AS IS, and neither the authors\n");
printf("# nor the University of Illinois, make any warranty about the\n");
printf("# software or its performance.\n");
printf("#\n");
dis_gcmd_line.display_info = 1;
dis_gcmd_line.debug = 0;
dis_gcmd_line.ehc = dis_TRUE;
dis_gcmd_line.optimize = dis_FALSE;
dis_gcmd_line.g_weight = 1;
dis_gcmd_line.h_weight = 1;
SymmLagrangian = 0;
SymmLagrange = 0;
GpG.subsolver = 0;
//dis_processdis__command_line(argc, argv);
/*
printf("dis_gcmd_line.g_weight = %d\n", dis_gcmd_line.g_weight );
printf("dis_gcmd_line.h_weight = %d\n", dis_gcmd_line.h_weight );
printf("dis_gcmd_line.ehc = %d\n", dis_gcmd_line.ehc );
printf("dis_gcmd_line.optimize = %d\n", dis_gcmd_line.optimize );
printf("dis_gcmd_line.display_info = %d\n", dis_gcmd_line.display_info );
printf("dis_gcmd_line.debug = %d\n", dis_gcmd_line.debug );
*/
//-------
so_signal_management();
strcpy (gcomm_line, "");
for (i = 0; i < argc; i++)
{
strcat (gcomm_line, argv[i]);
strcat (gcomm_line, " ");
}
get_path (*argv, glpg_path);
initialize_preset_values ();
#ifdef __STATISTIC_LM__
init_statistic();
#endif
/*Reset hash-table
*/
reset_cvar_hash_table();
/* Initialize random seed
*/
gettimeofday (&tv, &tz);
seed = ((tv.tv_sec & 0177) * 1000000) + tv.tv_usec;
/* command line treatment
*/
if (argc == 1 || (argc == 2 && *++argv[0] == '?'))
{
lpg_usage ();
exit (1);
}
gcmd_line.out_file_name[0] = 0;
if (!process_command_line (argc, argv))
{
lpg_usage ();
exit (1);
}
/* make file names
*/
/* one input name missing
*/
if (!gcmd_line.ops_file_name || !gcmd_line.fct_file_name)
{
fprintf (stdout, "\n%s: two input files needed\n\n", NAMEPRG);
lpg_usage ();
exit (1);
}
/* add path info, complete file names will be stored in
* ops_file and fct_file
*/
sprintf (ops_file, "%s%s", gcmd_line.path, gcmd_line.ops_file_name);
sprintf (fct_file, "%s%s", gcmd_line.path, gcmd_line.fct_file_name);
strcpy (gops_file, ops_file);
strcpy (gfct_file, fct_file);
sprintf (sol_file, "%s%s", gcmd_line.path, gcmd_line.sol_file_name);
/* parse the input files
*/
/* start parse & instantiation timing
*/
times (&glob_start_time);
times (&start);
/*
//GpG.feed_MFF_LPG = TRUE;
GpG.feed_MFF_LPG = FALSE;
if(GpG.feed_MFF_LPG) {
dis_MFF_main(ops_file, fct_file);
mff_to_lpg();
}
else
// START OF PARSING
{*/
/* domain file (ops)
*/
// ADL?
GpG.gis_ADL = ADL_ops_file(ops_file);
i = get_requirements(ops_file);
if((!GpG.is_deripred || i == 1 || !GpG.gis_ADL) && !GpG.is_goal_utilities && !GpG.is_action_costs) {
if(!i || !GpG.gis_ADL) {
printf ("\nParsing domain file\n");
fflush(stdout);
/* it is important for the pddl language to define the domain before
* reading the problem
*/
load_ops_file (ops_file);
// Y. Chen
if(gloaded_dps) {
// printf("\nSGPlan: Contains derived predicates\n");
GpG.is_deripred = TRUE;
}
else {
// printf("\nSGPlan: No derived predicates\n");
GpG.is_deripred = FALSE;
}
}
else
{
gdomain_name = dis_copy_dis_Token("PSR");
GpG.is_deripred = TRUE;
}
}
/* ============= Search Modal =======================
* Y. Chen
* Decide which parser to use here
*/
search_ops_modal();
//fprintf(stderr, "\nSearchModal = %d %d\n", GpG.SearchModal, GpG.SecondaryModal);
// MFF_parser
if((GpG.SearchModal == 5) || (GpG.SearchModal == 7)
|| (GpG.SearchModal == 6) || (GpG.SearchModal == 100)
|| (GpG.SearchModal == 104) || (GpG.SearchModal == 106)
|| (GpG.SearchModal == 107)
|| (GpG.SearchModal == -1) || (GpG.SearchModal <= -1000)) {
/*
Settlers 5
Sattelite 6 Sattelite TIME_TIMEWINDOWS_COMPILED 106
UMTS 7
Psr large 100 Psr middle-compiled 104
Promela OPTICAL_TELEGRAPH_FLUENTS PHILOSOPHERS_FLUENTS 107
*/
GpG.MFF_parser = TRUE;
} else {
GpG.MFF_parser = FALSE;
}
// ComputeMutex
if(((GpG.SearchModal == 0)||(GpG.SearchModal == 105))
|| (GpG.SearchModal == 3 && GpG.is_til )
) {
/*
Airport 0 Airport TEMPORAL_TIMEWINDOWS_COMPILED 105
Pipesworld NOTANKAGE_TEMPORAL_DEADLINES 3
*/
GpG.lowmemory = FALSE;
ComputeMutex = TRUE;
} else {
ComputeMutex = FALSE;
}
if(GpG.is_deripred) {
ComputeMutex = FALSE;
}
/* ==================================================*/
if(GpG.MFF_parser) {
mffDistributedSearch(ops_file, fct_file);
exit(0);
}
/* ===================================================
*/
transfer_PlDP_PlOperator();
/*dirty trick to get another copy of gloaded_ops */
if (GpG.is_til)
load_fct_file (fct_file);
gloaded_pl2ops = gloaded_ops;
gloaded_ops = NULL;
/* derived predicates */
gloaded_dps = NULL;
/* timed initial literals */
gnum_tils = 0;
g_tils = gtils = NULL;
gdomain_name = NULL;
gorig_initial_facts = NULL;
gorig_goal_facts = NULL;
gmetric_exp = NULL;
gloaded_axioms = NULL;
gparse_types = NULL;
gparse_constants = NULL;
gparse_predicates = NULL;
gparse_functions = NULL;
gparse_objects = NULL;
gorig_constant_list = NULL;
gpredicates_and_types = NULL;
gfunctions_and_types = NULL;
gloaded_constraints = NULL;
gloaded_preferences = NULL;
load_ops_file (ops_file);
// Y. Chen
transfer_PlDP_PlOperator();
/*add dummy effect to operators without boolean effects */
add_dummy_effects (gloaded_ops);
add_dummy_effects (gloaded_pl2ops);
/*counts numeric preconds and effects */
count_num_preconds_and_effects ();
GpG.gplan_actions = NULL;
/* problem file (facts)
*/
if (gcmd_line.display_info >= 1)
{
printf ("\nParsing problem file\n");
fflush(stdout);
}
load_fct_file (fct_file);
if (gcmd_line.display_info >= 1)
printf ("\n\n");
allocate_after_parser();
/* now we have PlOperators and PlNodes */
reduce_pddl2_to_pddl1 ();
/* This is needed to get all types.
*/
build_orig_constant_list ();
/* last step of parsing: see if it's an ADL domain!
*/
if (!make_adl_domain ())
{
printf ("\n%s: this is an ADL problem!", NAMEPRG);
printf ("\n can't be handled by this version.\n\n");
exit (1);
}
/* now instantiate operators;
*/
/**************************
* first do PREPROCESSING *
**************************/
/* start by collecting all strings and thereby encoding
* the domain in integers.
*/
encode_domain_in_integers ();
/* inertia preprocessing, first step:
* - collect inertia information
* - split initial state into
* _ arrays for individual predicates
* - arrays for all static relations
* - array containing non - static relations
*/
do_inertia_preprocessing_step_1 ();
/* normalize all PL1 formulae in domain description:
* (goal, preconds and effect conditions)
* - simplify formula
* - expand quantifiers
* - NOTs down
*/
normalize_all_wffs ();
/* translate negative preconds: introduce symmetric new predicate
* NOT-p(..) (e.g., not-in(?ob) in briefcaseworld)
*/
translate_negative_preconds ();
/* split domain in easy (disjunction of conjunctive preconds)
* and hard (non DNF preconds) part, to apply
* different instantiation algorithms
*/
split_domain ();
/***********************************************
* PREPROCESSING FINISHED *
* *
* NOW MULTIPLY PARAMETERS IN EFFECTIVE MANNER *
***********************************************/
build_easy_action_templates ();
build_hard_action_templates ();
times (&end);
TIME (gtempl_time);
times (&start);
check_time_and_length (0);
// Y.Chen
seed = 2004;
srandom(seed);
#ifdef __MY_OUTPUT__
printf ("\n Seed %d \n", seed);
#endif
/* perform reachability analysis in terms of relaxed
* fixpoint
*/
perform_reachability_analysis ();
times (&end);
TIME (greach_time);
times (&start);
check_time_and_length (0);
/* collect the relevant facts and build final domain
* and problem representations.
*/
collect_relevant_facts ();
times (&end);
TIME (grelev_time);
times (&start);
check_time_and_length (0);
/* now build globally accessable connectivity graph
*/
build_connectivity_graph ();
/*
}// END PARSING
*/
// Y. Chen
set_DPop_flag();
if(GpG.SearchModal != 3 && GpG.SearchModal != -2) {
if(!ComputeMutex) {
DistributeSearch(&ginitial_state, &ggoal_state, &subplan_actions);
exit(0);
}
}
times (&end);
TIME (gconn_time);
times (&start);
check_time_and_length (0);
/* association to gef_conn[i] a corresponding complet ploperator */
associate_PlOperator_with_EfConn ();
/* adding composed numeric quantities */
add_composite_vars ();
make_numgoal_state(GpG.numeric_goal_PlNode);
/* make false the comparison between uninitialized numeric quantities */
make_false_all_checks_on_not_init ();
/* Semplification for inertial vars
*/
propagate_inertias ();
if (GpG.SearchModal == -2)
{
mffDistributedSearch(ops_file, fct_file);
exit(0);
}
if(GpG.SearchModal == 3) {
if(!ComputeMutex) {
DistributeSearch(&ginitial_state, &ggoal_state, &subplan_actions);
exit(0);
}
}
if (DEBUG0)
if (GpG.non_strips_domain)
{
/*
if (GpG.variable_duration)
printf ("\n\nAction durations have been computed\n");
else
printf ("\n\nThere is no action duration to compute\n");*/
}
/* Set vars orig_weight_cost and orig_weight_time according with plan evaluation metric
*/
if (goptimization_exp != -1)
set_cost_and_time_coeffs ();
/*
if (DEBUG0)
printf("\nEvaluation function weights:\n Action duration %.2f; Action cost %.2f", GpG.orig_weight_time, GpG.orig_weight_cost);
if (DEBUG0)
printf ("\n\nTemporal flag: %s\n", GpG.temporal_plan ? "ON" : "OFF");
*/
/* Make numeric effects structure
*/
create_descnumeff_of_efconns ();
/* Sets flag is_numeric for each action (efconn)
*/
set_numeric_flag ();
assert (gnum_comp_var < MAX_NUM_VALUE);
/* Copy initial state in initial_state
*/
for (i = 0; i < gnum_comp_var; i++)
ginitial_state.V[i] = GCOMP_VAR_VALUE(i);
times (&end);
TIME (gnum_time);
times (&start);
/* Print information about action istantiation
*/
print_parser_info_for_debug();
//print_real_state(ginitial_state);
if(ComputeMutex) {
//if (GpG.numrun > 0 && GpG.numtry > 0) {
if (1) {
if (DEBUG0 && !DEBUG1) {
// printf ("\nComputing mutex... ");
// fflush (stdout);
}
if (DEBUG1)
printf ("\n\n--- COMPUTE MUTEX BETWEEN FACTS ---\n");
if (GpG.accurate_cost >= 1)
allocate_reachability_information_data();
/* Comute mutex between facts
*/
calc_mutex (&ginitial_state);
if (!are_goal_reachable_and_non_mutex ()) {
printf ("\nThe problem is unsolvable since at the fixpoint level the goals are mutex or not reachable\n\n");
exit (0);
}
}
times (&end);
TIME (gmutex_ft_time);
if (DEBUG2)
printf ("\n");
if (DEBUG1)
printf ("\n --> Compute mutex between facts TOTAL TIME: %12.2f",gmutex_ft_time);
times (&start);
//if (GpG.numrun > 0 && GpG.numtry > 0) {
if(1){
if (DEBUG1)
printf ("\n\n--- COMPUTE MUTEX BETWEEN ACTIONS ---\n");
/*Compute action-action, action_fact, fact-action mutex
*/
calc_mutex_ops ();
}
times (&end);
TIME (gmutex_ops_time);
if (DEBUG1)
printf ("\n --> Compute mutex between actions TOTAL TIME: %12.2f\n",gmutex_ops_time);
times (&start);
//if (GpG.numrun > 0 && GpG.numtry > 0) {
if(1){
if (DEBUG1)
printf ("\n\n--- COMPUTE MUTEX BETWEEN NUMERIC FACTS ---\n");
/* Compute mutex between action with numeric effects
*/
if (!GpG.lowmemory)
calc_mutex_num_efs ();
}
times (&end);
TIME (gmutex_num_time);
if (DEBUG1)
printf("\n --> Compute mutex between numeric facts TOTAL TIME: %12.2f\n",gmutex_num_time);
if (DEBUG2)
print_mutex_result ();
if (DEBUG0 && !DEBUG1) {
// printf ("done");
// fflush (stdout);
}
times (&start);
//if (DEBUG6 && !GpG.lowmemory)
print_matrs ();
gmutex_total_time = gmutex_ft_time + gmutex_ops_time + gmutex_num_time;
}
if (strlen (gcmd_line.sol_file_name) > 0)
load_pddl2_plan (sol_file, &GpG.gplan_actions, 0);
if (GpG.SearchModal == 3)
ComputeMutex = FALSE;
GpG.max_num_actions = gnum_ef_conn;
GpG.max_num_facts = gnum_ft_conn;
GpG.max_num_ft_block = gnum_ft_block;
/***********************************************************
* we are finally through with preprocessing and can worry *
* about finding a plan instead. *
***********************************************************/
/* another quick preprocess: approximate goal orderings and split
* goal set into sequence of smaller sets, the goal agenda
*/
// Yixin
if(ComputeMutex) {
modify_ft_ef_mutex();
compute_goal_agenda();
}
// printf ("******************\n");
/*
source_to_dest( &(gplan_states[0]), &ginitial_state );
source_to_dest( ¤t_start, &ginitial_state );
source_to_dest( ¤t_end, &(ggoal_agenda[0]) );
for ( i = 0; i < gnum_goal_agenda; i++ ) {
if ( !do_enforced_hill_climbing( ¤t_start, ¤t_end ) ) {
break;
}
source_to_dest( ¤t_start, &(gplan_states[gnum_plan_ops]) );
if ( i < gnum_goal_agenda - 1 ) {
for ( j = 0; j < ggoal_agenda[i+1].num_F; j++ ) {
current_end.F[current_end.num_F++] = ggoal_agenda[i+1].F[j];
}
}
}
found_plan = ( i == gnum_goal_agenda ) ? TRUE : FALSE;
*/
source_to_dest (&(gplan_states[0]), &ginitial_state);
source_to_dest (¤t_start, &ginitial_state);
source_to_dest (¤t_end, &ggoal_state);
remove_unappliable_actions ();
if ((GpG.search_type == LOCAL && GpG.numrun > 0 && GpG.numtry > 0) ||
GpG.search_type == DIS_SEARCH )
{
k = MAX (GpG.input_plan_lenght, gmutex_level);
for (i = 0; i < k; i++)
{
if (i < gmutex_level)
create_vectlevel (0);
else
create_vectlevel (1);
}
allocate_data_for_local_search();
create_all_min_array ();
GpG.fixpoint_plan_length = GpG.max_plan_length - 1;
GpG.saved_fixpoint_plan_length = GpG.fixpoint_plan_length ;
GpG.curr_goal_state = ¤t_end;
}
if (DEBUG1) {
printf ("\n\nTime spent for preprocessing:");
printf ("\n Instantiating: %7.2f seconds", gtempl_time + greach_time + grelev_time + gconn_time + gsearch_time);
printf ("\n Mutex relations: %7.2f seconds", gmutex_total_time);
printf ("\n Numeric relations: %7.2f seconds", gnum_time);
}
if (DEBUG0) {
times (&glob_end_time);
gtotal_time = (float) ((glob_end_time.tms_utime - glob_start_time.tms_utime + glob_end_time.tms_stime - glob_start_time.tms_stime) / 100.0);
// printf ("\nPreprocessing total time: %.2f seconds",gtotal_time);
}
/*
printf ("\n\ninitial state is:\n\n");
for (i = 0; i < ginitial_state.num_F; i++)
{
print_ft_name (current_start.F[i]);
printf ("\n");
}
printf ("\n\ngoal state is:\n\n");
for (i = 0; i < current_end.num_F; i++)
{
print_ft_name (current_end.F[i]);
printf ("\n");
}
printf("GpG.fixpoint_plan_length = ",
GpG.fixpoint_plan_length);
*/
#ifdef __TEST__
for (i = 0; i < gnum_op_conn; i++)
{
print_op_name(i);
printf(" -- %f \n", get_action_cost (i));
}
#endif
if (GpG.do_best_first == TRUE && GpG.numrun==0)
GpG.search_type=BEST_FIRST;
/* Search untill it is not reached termination condition (given by the function 'is_term_condition_reached')
*/
while(!is_terminated)
{
/* Different types of local search
*/
switch(GpG.search_type)
{
/* Local Search usually used in LPG
*/
case DIS_SEARCH:
DistributeSearch(¤t_start, ¤t_end, &subplan_actions);
GpG.gplan_actions = subplan_actions;
subplan_actions = NULL;
is_terminated=TRUE;
break;
case LOCAL:
/* Do Local Search
*/
LocalSearch (¤t_start, ¤t_end, &subplan_actions);
/* Store plan in GpG.gplan_actions
*/
GpG.gplan_actions = subplan_actions;
subplan_actions = NULL;
/* Control if the termination condition is reached
*/
is_terminated=TRUE;
//is_terminated= is_term_condition_reached();
break;
/* Best First Search implemented by J. Hoffmann (FF-v2.3)
*/
case BEST_FIRST:
// strips_gef_conn();
// load_ff_gef_conn();
if (DEBUG0)
printf("\n\nSwitching to Best-first Search ( code from J. Hoffmann's package FF-v2.3 ) \n");
check_time_and_length (0); /* con zero non controlla la lunghezza */
/* Return solution if reached, FALSE otherwise
*/
found_plan = do_best_first_search ();
printf("do_best_first_search");
//if (do_enforced_hill_climbing (¤t_start, ¤t_end))
//printf("do_hill");
times (&end);
TIME (gsearch_time);
times (&end);
times (&glob_end_time);
gtotal_time = (float) ((glob_end_time.tms_utime - glob_start_time.tms_utime + glob_end_time.tms_stime - glob_start_time.tms_stime) / 100.0);
/* If a solution was found in best first search print solution
*/
if (found_plan)
{
#ifdef __MY_OUTPUT__
printf ("\nFFGGHH::%.2f::%d\n", gtotal_time, gnum_plan_ops);
#endif
store_adapted_temporal_plan_ff (gcmd_line.fct_file_name);
printf ("\nTotal time: %.2f\nSearch time: %.2f\nActions: %d\nExecution cost: %.2f\nDuration: %.3f\nPlan quality: %.3f", gtotal_time, gsearch_time, GpG.num_actions, GpG.total_cost, GpG.total_time,GpG.total_cost * GpG.orig_weight_cost + GpG.total_time * GpG.orig_weight_time);
printf ("\n Plan file:");
printf (" plan_bestfirst_%s.SOL", gcmd_line.fct_file_name);
}
if (DEBUG1)
output_planner_info ();
/* Control if the termination condition is reached
*/
is_terminated= is_term_condition_reached();
break;
/* Hill Climbing Search
*/
case HILL_CLIMBING:
if (do_enforced_hill_climbing (¤t_start, ¤t_end))
source_to_dest (¤t_start, &(gplan_states[gnum_plan_ops]));
printf("do_hill");
/* Control if the termination condition is reached
*/
is_terminated= is_term_condition_reached();
break;
default:
/* Control if the termination condition is reached
*/
is_terminated= is_term_condition_reached();
break;
}
if (DEBUG2)
{
printf ("\n\nInitial state is:\n\n");
for (j = 0; j < ginitial_state.num_F; j++)
{
print_ft_name (current_start.F[j]);
printf ("\n");
}
printf ("\n\nGoal state is:\n\n");
for (j = 0; j < current_end.num_F; j++)
{
print_ft_name (current_end.F[j]);
printf ("\n");
}
}
}
printf ("\n\n");
printf ("\nTotal time: %.3f\n", gtotal_time);
exit (0);
}