void encode_domain_in_integers( void )
{
int i,j;
collect_all_strings();
if ( gcmd_line.display_info == 102 ) {
printf("\nconstant table:");
for ( i = 0; i < gnum_constants; i++ ) {
printf("\n%d --> %s", i, gconstants[i]);
}
printf("\n\ntypes table:");
for ( i = 0; i < gnum_types; i++ ) {
printf("\n%d --> %s: ", i, gtype_names[i]);
for ( j = 0; j < gtype_size[i]; j++ ) {
printf("%d ", gtype_consts[i][j]);
}
}
printf("\n\npredicates table:");
for ( i = 0; i < gnum_predicates; i++ ) {
printf("\n%3d --> %s: ", i, gpredicates[i]);
for ( j = 0; j < garity[i]; j++ ) {
printf("%s ", gtype_names[gpredicates_args_type[i][j]]);
}
}
printf("\n\n");
}
create_integer_representation();
cleanup_domain();
if ( gcmd_line.display_info == 103 ) {
printf("\n\ncoded initial state is:");
for ( i = 0; i < gnum_full_initial; i++ ) {
printf("\n");
print_Fact( &(gfull_initial[i]) );
}
printf("\n\ncoded goal state is:");
for ( i = 0; i < gnum_goal; i++ ) {
printf("\n");
print_Fact( &(ggoal[i]) );
}
printf("\n\ncoded operators are:");
for ( i = 0; i < gnum_operators; i++ ) {
print_Operator( goperators[i] );
}
printf("\n\n");
}
}
void print_NormOperator( NormOperator *o )
{
NormEffect *e;
int i, m;
printf("\n\n----------------Operator %s, normalized form--------------\n",
o->op->name);
for ( i = 0; i < o->num_vars; i++ ) {
printf("\nx%d of type ", i);
print_type( o->var_types[i] );
}
printf("\n\n%d vars removed from original operator:",
o->num_removed_vars);
for ( i = 0; i < o->num_removed_vars; i++ ) {
m = o->removed_vars[i];
printf("\nx%d (%s) of type %s, type constraint ", m, o->op->var_names[m],
gtype_names[o->op->var_types[m]]);
print_type( o->type_removed_vars[i] );
}
printf("\nPreconds:\n");
for ( i = 0; i < o->num_preconds; i++ ) {
print_Fact( &(o->preconds[i]) );
printf("\n");
}
m = 0;
printf("\n\nEffects:");
for ( e = o->effects; e; e = e->next ) {
printf("\n\neffect %d, parameters %d", m++, e->num_vars);
for ( i = 0; i < e->num_vars; i++ ) {
printf("\nx%d of type ", o->num_vars + i);
print_type( e->var_types[i] );
}
printf("\nConditions, P %lf:\n", e->eff_p);/* july 06 */
for ( i = 0; i < e->num_conditions; i++ ) {
print_Fact( &(e->conditions[i]) );
printf("\n");
}
printf("\nAdds\n");
for ( i = 0; i < e->num_adds; i++ ) {
print_Fact( &(e->adds[i]) );
printf("\n");
}
printf("\nDels\n");
for ( i = 0; i < e->num_dels; i++ ) {
print_Fact( &(e->dels[i]) );
printf("\n");
}
}
}
void print_ft_name( int index )
{
print_Fact( &(grelevant_facts[index]) );
}
void print_MixedOperator( MixedOperator *o )
{
int i, m;
Effect *e;
Literal *l;
printf("\n\n----------------Operator %s, mixed form--------------\n",
o->op->name);
for ( i = 0; i < o->op->num_vars; i++ ) {
printf("\nx%d = %s of type ", i, gconstants[o->inst_table[i]]);
print_type( o->op->var_types[i] );
}
printf("\nPreconds:\n");
for ( i = 0; i < o->num_preconds; i++ ) {
print_Fact( &(o->preconds[i]) );
printf("\n");
}
m = 0;
printf("\n\nEffects:");
for ( e = o->effects; e; e = e->next ) {
printf("\n\neffect %d, parameters %d", m++, e->num_vars);
for ( i = 0; i < e->num_vars; i++ ) {
printf("\nx%d of type %s",
o->op->num_vars + i, gtype_names[e->var_types[i]]);
}
printf("\nConditions, P %lf:\n", e->eff_p);/* july 06 */
print_Wff( e->conditions, 0 );
printf("\nEffect Literals");
for ( l = e->effects; l; l = l->next ) {
if ( l->negated ) {
printf("\nNOT ");
} else {
printf("\n");
}
print_Fact( &(l->fact) );
}
}
}
void print_PseudoAction( PseudoAction *o )
{
PseudoActionEffect *e;
int i, m;
printf("\n\n----------------Pseudo Action %s--------------\n",
o->op->name);
for ( i = 0; i < o->op->num_vars; i++ ) {
printf("\nx%d = %s of type ", i, gconstants[o->inst_table[i]]);
print_type( o->op->var_types[i] );
}
printf("\nPreconds:\n");
for ( i = 0; i < o->num_preconds; i++ ) {
print_Fact( &(o->preconds[i]) );
printf("\n");
}
m = 0;
printf("\n\nEffects:");
for ( e = o->effects; e; e = e->next ) {
printf("\n\neffect %d", m++);
printf("\n\nConditions, P %lf:\n", e->eff_p);/* july 06 */
for ( i = 0; i < e->num_conditions; i++ ) {
print_Fact( &(e->conditions[i]) );
printf("\n");
}
printf("\nAdds\n");
for ( i = 0; i < e->num_adds; i++ ) {
print_Fact( &(e->adds[i]) );
printf("\n");
}
printf("\nDels\n");
for ( i = 0; i < e->num_dels; i++ ) {
print_Fact( &(e->dels[i]) );
printf("\n");
}
}
}
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(")");
}
}
void print_Operator( Operator *o )
{
Effect *e;
Literal *l;
int i, m = 0;
printf("\n\n----------------Operator %s, translated form, step 1--------------\n", o->name);
for ( i = 0; i < o->num_vars; i++ ) {
printf("\nx%d (%s) of type %s, removed ? %s",
i, o->var_names[i], gtype_names[o->var_types[i]],
o->removed[i] ? "YES" : "NO");
}
printf("\ntotal params %d, real params %d\n",
o->num_vars, o->number_of_real_params);
printf("\nPreconds:\n");
print_Wff( o->preconds, 0 );
printf("\n\nEffects:");
for ( e = o->effects; e; e = e->next ) {
printf("\n\neffect %d, parameters %d", m++, e->num_vars);
for ( i = 0; i < e->num_vars; i++ ) {
printf("\nx%d (%s) of type %s",
o->num_vars + i, e->var_names[i], gtype_names[e->var_types[i]]);
}
printf("\nConditions, P %lf:\n", e->eff_p);/* july06 */
print_Wff( e->conditions, 0 );
printf("\nEffect Literals");
for ( l = e->effects; l; l = l->next ) {
if ( l->negated ) {
printf("\nNOT ");
} else {
printf("\n");
}
print_Fact( &(l->fact) );
}
}
}
void print_MixedOperator( MixedOperator *o )
{
int i, m;
Effect *e;
NumericEffect *ne;
Literal *l;
printf("\n\n----------------Operator %s, mixed form--------------\n",
o->operator->name);
for ( i = 0; i < o->operator->num_vars; i++ ) {
printf("\nx%d = %s of type ", i, gconstants[o->inst_table[i]]);
print_type( o->operator->var_types[i] );
}
printf("\nPreconds:\n");
for ( i = 0; i < o->num_preconds; i++ ) {
print_Fact( &(o->preconds[i]) );
printf("\n");
}
for ( i = 0; i < o->num_numeric_preconds; i++ ) {
switch ( o->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 mixedpre %d\n\n",
o->numeric_preconds_comp[i]);
exit( 1 );
}
print_ExpNode( o->numeric_preconds_lh[i] );
print_ExpNode( o->numeric_preconds_rh[i] );
printf(")\n");
}
m = 0;
printf("\n\nEffects:");
for ( e = o->effects; e; e = e->next ) {
printf("\n\neffect %d, parameters %d", m++, e->num_vars);
for ( i = 0; i < e->num_vars; i++ ) {
printf("\nx%d of type %s",
o->operator->num_vars + i, gtype_names[e->var_types[i]]);
}
printf("\nConditions\n");
print_Wff( e->conditions, 0 );
printf("\nEffect Literals");
for ( l = e->effects; l; l = l->next ) {
if ( l->negated ) {
printf("\nNOT ");
} else {
printf("\n");
}
print_Fact( &(l->fact) );
}
printf("\nNumeric Effects");
for ( ne = e->numeric_effects; ne; ne = ne->next ) {
switch ( ne->neft ) {
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 effect: illegal neft %d\n\n", ne->neft);
exit( 1 );
}
print_Fluent( &(ne->fluent) );
print_ExpNode( ne->rh );
}
}
}
void print_NormOperator( NormOperator *o )
{
NormEffect *e;
int i, m;
printf("\n\n----------------Operator %s, normalized form--------------\n",
o->operator->name);
for ( i = 0; i < o->num_vars; i++ ) {
printf("\nx%d of type ", i);
print_type( o->var_types[i] );
}
printf("\n\n%d vars removed from original operator:",
o->num_removed_vars);
for ( i = 0; i < o->num_removed_vars; i++ ) {
m = o->removed_vars[i];
printf("\nx%d (%s) of type %s, type constraint ", m, o->operator->var_names[m],
gtype_names[o->operator->var_types[m]]);
print_type( o->type_removed_vars[i] );
}
printf("\nPreconds:\n");
for ( i = 0; i < o->num_preconds; i++ ) {
print_Fact( &(o->preconds[i]) );
printf("\n");
}
for ( i = 0; i < o->num_numeric_preconds; i++ ) {
switch ( o->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 normpre %d\n\n",
o->numeric_preconds_comp[i]);
exit( 1 );
}
print_ExpNode( o->numeric_preconds_lh[i] );
print_ExpNode( o->numeric_preconds_rh[i] );
printf(")\n");
}
m = 0;
printf("\n\nEffects:");
for ( e = o->effects; e; e = e->next ) {
printf("\n\neffect %d, parameters %d", m++, e->num_vars);
for ( i = 0; i < e->num_vars; i++ ) {
printf("\nx%d of type ", o->num_vars + i);
print_type( e->var_types[i] );
}
printf("\nConditions\n");
for ( i = 0; i < e->num_conditions; i++ ) {
print_Fact( &(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_Fact( &(e->adds[i]) );
printf("\n");
}
printf("\nDels\n");
for ( i = 0; i < e->num_dels; i++ ) {
print_Fact( &(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 );
}
print_Fluent( &(e->numeric_effects_fluent[i]) );
print_ExpNode( e->numeric_effects_rh[i] );
}
}
}
void print_Operator( Operator *o )
{
Effect *e;
Literal *l;
NumericEffect *ne;
int i, m = 0;
printf("\n\n----------------Operator %s, translated form, step 1--------------\n", o->name);
for ( i = 0; i < o->num_vars; i++ ) {
printf("\nx%d (%s) of type %s, removed ? %s",
i, o->var_names[i], gtype_names[o->var_types[i]],
o->removed[i] ? "YES" : "NO");
}
printf("\ntotal params %d, real params %d\n",
o->num_vars, o->number_of_real_params);
printf("\nPreconds:\n");
print_Wff( o->preconds, 0 );
printf("\n\nEffects:");
for ( e = o->effects; e; e = e->next ) {
printf("\n\neffect %d, parameters %d", m++, e->num_vars);
for ( i = 0; i < e->num_vars; i++ ) {
printf("\nx%d (%s) of type %s",
o->num_vars + i, e->var_names[i], gtype_names[e->var_types[i]]);
}
printf("\nConditions\n");
print_Wff( e->conditions, 0 );
printf("\nEffect Literals");
for ( l = e->effects; l; l = l->next ) {
if ( l->negated ) {
printf("\nNOT ");
} else {
printf("\n");
}
print_Fact( &(l->fact) );
}
printf("\nNumeric Effects");
for ( ne = e->numeric_effects; ne; ne = ne->next ) {
switch ( ne->neft ) {
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 effect: illegal neft %d\n\n", ne->neft);
exit( 1 );
}
print_Fluent( &(ne->fluent) );
print_ExpNode( ne->rh );
}
}
}
void print_Wff( WffNode *n, int indent )
{
WffNode *i;
if ( !n ) {
printf("none\n");
return;
}
switch (n->connective) {
case ALL:
printf("ALL x%d (%s): %s\n", n->var, n->var_name,
gtype_names[n->var_type]);
print_indent(indent);
printf("( ");
print_Wff(n->son,indent+4);
print_indent(indent);
printf(")\n");
break;
case EX:
printf("EX x%d (%s) : %s\n", n->var, n->var_name,
gtype_names[n->var_type]);
print_indent(indent);
printf("( ");
print_Wff(n->son,indent+4);
print_indent(indent);
printf(")\n");
break;
case AND:
printf("A( ");
print_Wff(n->sons, indent+4);
if ( n->sons ) {
for ( i = n->sons->next; i!=NULL; i = i->next ) {
if ( !i->prev ) {
printf("\nprev in AND not correctly set!\n\n");
exit( 1 );
}
print_indent(indent);
printf("AND ");
print_Wff(i,indent+4);
}
}
print_indent(indent);
printf(")\n");
break;
case OR:
printf("O( ");
print_Wff(n->sons, indent+4);
for ( i = n->sons->next; i!=NULL; i = i->next ) {
print_indent(indent);
printf("OR ");
print_Wff(i,indent+4);
}
print_indent(indent);
printf(")\n");
break;
case NOT:
if (ATOM==n->son->connective) {
printf("NOT ");
print_Wff(n->son,indent+4);
} else {
printf("NOT(");
print_Wff(n->son,indent+4);
print_indent(indent+3);
printf(")\n");
}
break;
case ATOM:
print_Fact(n->fact);
if ( n->NOT_p != -1 ) printf(" - translation NOT");
printf("\n");
break;
case TRU:
printf("(TRUE)\n");
break;
case FAL:
printf("(FALSE)\n");
break;
case COMP:
switch (n->comp) {
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 WFF %d\n\n", n->comp);
exit( 1 );
}
print_ExpNode( n->lh );
print_ExpNode( n->rh );
printf(")\n");
break;
default:
printf("\n***** ERROR ****");
printf("\nprint_Wff: %d > Wrong Node specifier\n", n->connective);
exit(1);
}
}
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 do_inertia_preprocessing( void )
{
int i, j;
collect_inertia_information();
if ( gcmd_line.display_info == 104 ) {
printf("\n\npredicates inertia info:");
for ( i = 0; i < gnum_predicates; i++ ) {
printf("\n%3d --> %s: ", i, gpredicates[i]);
printf(" is %s, %s",
gis_added[i] ? "ADDED" : "NOT ADDED",
gis_deleted[i] ? "DELETED" : "NOT DELETED");
}
printf("\n\n");
}
split_initial_state();
if ( gcmd_line.display_info == 105 ) {
printf("\n\nfull initial state was:");
for ( i = 0; i < gnum_full_initial; i++ ) {
printf("\n");
print_Fact( &(gfull_initial[i]) );
if ( garity[gfull_initial[i].predicate] == 1 ) {
printf(" --> obj. number %d", gfull_initial[i].args[0]);
}
}
printf("\n\nsplitted initial state is:");
printf("\n\nextended types table:");
for ( i = 0; i < gnum_types; i++ ) {
printf("\n%d --> ", i);
if ( gpredicate_to_type[i] == -1 ) {
printf("%s ", gtype_names[i]);
} else {
printf("UNARY INERTIA TYPE (%s) ", gpredicates[gpredicate_to_type[i]]);
}
for ( j = 0; j < gtype_size[i]; j++ ) {
printf("%d ", gtype_consts[i][j]);
}
}
printf("\n\nnon static initial state:");
for ( i = 0; i < gnum_initial; i++ ) {
printf("\n");
print_Fact( &(ginitial[i]) );
}
printf("\n\nstatic initial state:");
for ( i = 0; i < gnum_inertia; i++ ) {
printf("\n");
print_Fact( &(ginertia[i]) );
}
printf("\n\n");
}
encode_unary_inertia_as_types();
remove_ops_with_empty_parameter_types();
remove_unused_parameters();
if ( gcmd_line.display_info == 106 ) {
printf("\n\nfull initial state was:");
for ( i = 0; i < gnum_full_initial; i++ ) {
printf("\n");
print_Fact( &(gfull_initial[i]) );
if ( garity[gfull_initial[i].predicate] == 1 ) {
printf(" --> obj. number %d", gfull_initial[i].args[0]);
}
}
printf("\n\nintersections extended types table:");
for ( i = 0; i < gnum_types; i++ ) {
printf("\n%d --> ", i);
if ( gpredicate_to_type[i] == -1 ) {
if ( gnum_intersected_types[i] == -1 ) {
printf("%s: ", gtype_names[i]);
} else {
printf("INTERSECTED TYPE (");
for ( j = 0; j < gnum_intersected_types[i]; j++ ) {
if ( gpredicate_to_type[gintersected_types[i][j]] == -1 ) {
printf("%s", gtype_names[gintersected_types[i][j]]);
} else {
printf("UNARY INERTIA TYPE (%s)",
gpredicates[gpredicate_to_type[gintersected_types[i][j]]]);
}
if ( j < gnum_intersected_types[i] - 1 ) {
printf(" and ");
}
}
printf("): ");
}
} else {
printf("UNARY INERTIA TYPE (%s): ", gpredicates[gpredicate_to_type[i]]);
}
for ( j = 0; j < gtype_size[i]; j++ ) {
printf("%d ", gtype_consts[i][j]);
}
}
printf("\n\nops with unary inertia preconds encoded:");
for ( i = 0; i < gnum_operators; i++ ) {
print_Operator( goperators[i] );
}
printf("\n\n");
}
}
void perform_reachability_analysis( void )
{
int size, i, j, adr;
Bool fixpoint;
ActionTemplate *t1, *t2, *t3;
Operator *o;
Action *tmp, *a;
for ( i = 0; i < gnum_predicates; i++ ) {
size = 1;
for ( j = 0; j < garity[i]; j++ ) {
size *= gnum_constants;
}
lpos[i] = ( int_pointer ) calloc( size, sizeof( int ) );
lneg[i] = ( int_pointer ) calloc( size, sizeof( int ) );
luse[i] = ( int_pointer ) calloc( size, sizeof( int ) );
lindex[i] = ( int_pointer ) calloc( size, sizeof( int ) );
for ( j = 0; j < size; j++ ) {
lpos[i][j] = 0;
lneg[i][j] = 0;
luse[i][j] = 0;
lindex[i][j] = -1;
}
}
/* mark initial facts as possibly positive
*/
for ( i = 0; i < gnum_initial; i++ ) {
lp = ginitial[i].predicate;
for ( j = 0; j < garity[lp]; j++ ) {
largs[j] = ginitial[i].args[j];
}
lpos[lp][fact_adress()] = 1;
}
/* compute fixpoint
*/
fixpoint = FALSE;
while ( !fixpoint ) {
fixpoint = TRUE;
t1 = gtemplates;
while ( t1 ) {
o = goperators[t1->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], t1 );
}
if ( !lpos[lp][fact_adress()] ) {
break;
}
}
if ( i < o->num_preconds ) {
break;
}
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], t1 );
}
adr = fact_adress();
if ( !lpos[lp][adr] ) {
/* new relevant fact! (added non initial)
*/
lpos[lp][adr] = 1;
lneg[lp][adr] = 1;
luse[lp][adr] = 1;
if ( gnum_relevant_facts == MAX_RELEVANT_FACTS ) {
printf("\ntoo many relevant facts! increase MAX_RELEVANT_FACTS (currently %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++;
fixpoint = FALSE;
}
}
tmp = new_Action( t1->op );
for ( i = 0; i < o->num_vars; i++ ) {
tmp->inst_table[i] = t1->inst_table[i];
}
tmp->next = gactions;
gactions = tmp;
gnum_actions++;
t2 = t1;
t1 = t1->next;
free_single_ActionTemplate( t2 );
}
gtemplates = t1;
t3 = t1;
if ( t1 ) t1 = t1->next;
while ( t1 ) {
o = goperators[t1->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], t1 );
}
if ( !lpos[lp][fact_adress()] ) {
break;
}
}
if ( i == o->num_preconds ) {
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], t1 );
}
adr = fact_adress();
if ( !lpos[lp][adr] ) {
/* new relevant fact! (added non initial)
*/
lpos[lp][adr] = 1;
lneg[lp][adr] = 1;
luse[lp][adr] = 1;
if ( gnum_relevant_facts == MAX_RELEVANT_FACTS ) {
printf("\ntoo many relevant facts! increase MAX_RELEVANT_FACTS (currently %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++;
fixpoint = FALSE;
}
}
tmp = new_Action( t1->op );
for ( i = 0; i < o->num_vars; i++ ) {
tmp->inst_table[i] = t1->inst_table[i];
}
tmp->next = gactions;
gactions = tmp;
gnum_actions++;
t3->next = t1->next;
t2 = t1;
t1 = t1->next;
free_single_ActionTemplate( t2 );
} else {
t3 = t3->next;
t1 = t1->next;
}
}
}
gnum_pp_facts = gnum_initial + gnum_relevant_facts;
if ( gcmd_line.display_info == 109 ) {
printf("\nreachability analysys came up with:");
printf("\n\npossibly positive facts:");
for ( i = 0; i < gnum_initial; i++ ) {
printf("\n");
print_Fact( &(ginitial[i]) );
}
for ( i = 0; i < gnum_relevant_facts; i++ ) {
printf("\n");
print_Fact( &(grelevant_facts[i]) );
}
printf("\n\nthis yields these %d action templates:", gnum_actions);
for ( i = 0; i < gnum_operators; i++ ) {
printf("\n\noperator %s:", goperators[i]->name);
for ( a = gactions; a; a = a->next ) {
if ( a->op != i ) {
continue;
}
printf("\ntemplate: ");
for ( j = 0; j < goperators[i]->num_vars; j++ ) {
printf("%s", gconstants[a->inst_table[j]]);
if ( j < goperators[i]->num_vars-1 ) {
printf(" ");
}
}
}
}
printf("\n\n");
}
/* if a goal is not possibly positive, the problem
* is unsolvable.
*/
for ( i = 0; i < gnum_goal; i++ ) {
lp = ggoal[i].predicate;
for ( j = 0; j < garity[lp]; j++ ) {
largs[j] = ggoal[i].args[j];
}
if ( !lpos[lp][fact_adress()] ) {
printf("\nproblem is unsolvable! goals can't be reached\n\n");
output_planner_info();
}
}
}
void perform_reachability_analysis( void )
{
int size, i, j, k, adr, num, pargtype;
Bool fixpoint;
Facts *f;
NormOperator *no;
EasyTemplate *t1, *t2;
NormEffect *ne;
Action *tmp, *a;
Bool *had_hard_template;
PseudoAction *pa;
PseudoActionEffect *pae;
gactions = NULL;
gnum_actions = 0;
for ( i = 0; i < gnum_predicates; i++ ) {
size = 1;
for ( j = 0; j < garity[i]; j++ ) {
pargtype = gpredicates_args_type[i][j];
size *= gtype_size[pargtype];
}
lpos[i] = ( int_pointer ) calloc( size, sizeof( int ) );
lneg[i] = ( int_pointer ) calloc( size, sizeof( int ) );
luse[i] = ( int_pointer ) calloc( size, sizeof( int ) );
lindex[i] = ( int_pointer ) calloc( size, sizeof( int ) );
for ( j = 0; j < size; j++ ) {
lpos[i][j] = 0;
lneg[i][j] = 1;/* all facts but initials are poss. negative */
luse[i][j] = 0;
lindex[i][j] = -1;
}
}
had_hard_template = ( Bool * ) calloc( gnum_hard_templates, sizeof( Bool ) );
for ( i = 0; i < gnum_hard_templates; i++ ) {
had_hard_template[i] = FALSE;
}
/* mark initial facts as possibly positive, not poss. negative
*/
for ( i = 0; i < gnum_predicates; i++ ) {
lp = i;
for ( j = 0; j < gnum_initial_predicate[i]; j++ ) {
for ( k = 0; k < garity[i]; k++ ) {
largs[k] = ginitial_predicate[i][j].args[k];
}
adr = fact_adress();
lpos[lp][adr] = 1;
lneg[lp][adr] = 0;
}
}
/* compute fixpoint
*/
fixpoint = FALSE;
while ( !fixpoint ) {
fixpoint = TRUE;
/* assign next layer of easy templates to possibly positive fixpoint
*/
t1 = geasy_templates;
while ( t1 ) {
no = t1->op;
for ( i = 0; i < no->num_preconds; i++ ) {
lp = no->preconds[i].predicate;
for ( j = 0; j < garity[lp]; j++ ) {
largs[j] = ( no->preconds[i].args[j] >= 0 ) ?
no->preconds[i].args[j] : t1->inst_table[DECODE_VAR( no->preconds[i].args[j] )];
}
if ( !lpos[lp][fact_adress()] ) {
break;
}
}
if ( i < no->num_preconds ) {
t1 = t1->next;
continue;
}
num = 0;
for ( ne = no->effects; ne; ne = ne->next ) {
num++;
/* currently, simply ignore effect conditions and assume
* they will all be made true eventually.
*/
for ( i = 0; i < ne->num_adds; i++ ) {
lp = ne->adds[i].predicate;
for ( j = 0; j < garity[lp]; j++ ) {
largs[j] = ( ne->adds[i].args[j] >= 0 ) ?
ne->adds[i].args[j] : t1->inst_table[DECODE_VAR( ne->adds[i].args[j] )];
}
adr = fact_adress();
if ( !lpos[lp][adr] ) {
/* new relevant fact! (added non initial)
*/
lpos[lp][adr] = 1;
lneg[lp][adr] = 1;
luse[lp][adr] = 1;
if ( gnum_relevant_facts == MAX_RELEVANT_FACTS ) {
printf("\ntoo many relevant facts! increase MAX_RELEVANT_FACTS (currently %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++;
fixpoint = FALSE;
}
}
}
tmp = new_Action();
tmp->norm_operator = no;
for ( i = 0; i < no->num_vars; i++ ) {
tmp->inst_table[i] = t1->inst_table[i];
}
tmp->name = no->operator->name;
tmp->num_name_vars = no->operator->number_of_real_params;
make_name_inst_table_from_NormOperator( tmp, no, t1 );
tmp->next = gactions;
tmp->num_effects = num;
gactions = tmp;
gnum_actions++;
t2 = t1->next;
if ( t1->next ) {
t1->next->prev = t1->prev;
}
if ( t1->prev ) {
t1->prev->next = t1->next;
} else {
geasy_templates = t1->next;
}
free_single_EasyTemplate( t1 );
t1 = t2;
}
/* now assign all hard templates that have not been transformed
* to actions yet.
*/
for ( i = 0; i < gnum_hard_templates; i++ ) {
if ( had_hard_template[i] ) {
continue;
}
pa = ghard_templates[i];
for ( j = 0; j < pa->num_preconds; j++ ) {
lp = pa->preconds[j].predicate;
for ( k = 0; k < garity[lp]; k++ ) {
largs[k] = pa->preconds[j].args[k];
}
if ( !lpos[lp][fact_adress()] ) {
break;
}
}
if ( j < pa->num_preconds ) {
continue;
}
for ( pae = pa->effects; pae; pae = pae->next ) {
/* currently, simply ignore effect conditions and assume
* they will all be made true eventually.
*/
for ( j = 0; j < pae->num_adds; j++ ) {
lp = pae->adds[j].predicate;
for ( k = 0; k < garity[lp]; k++ ) {
largs[k] = pae->adds[j].args[k];
}
adr = fact_adress();
if ( !lpos[lp][adr] ) {
/* new relevant fact! (added non initial)
*/
lpos[lp][adr] = 1;
lneg[lp][adr] = 1;
luse[lp][adr] = 1;
if ( gnum_relevant_facts == MAX_RELEVANT_FACTS ) {
printf("\ntoo many relevant facts! increase MAX_RELEVANT_FACTS (currently %d)\n\n",
MAX_RELEVANT_FACTS);
exit( 1 );
}
grelevant_facts[gnum_relevant_facts].predicate = lp;
for ( k = 0; k < garity[lp]; k++ ) {
grelevant_facts[gnum_relevant_facts].args[k] = largs[k];
}
lindex[lp][adr] = gnum_relevant_facts;
gnum_relevant_facts++;
fixpoint = FALSE;
}
}
}
tmp = new_Action();
tmp->pseudo_action = pa;
for ( j = 0; j < pa->operator->num_vars; j++ ) {
tmp->inst_table[j] = pa->inst_table[j];
}
tmp->name = pa->operator->name;
tmp->num_name_vars = pa->operator->number_of_real_params;
make_name_inst_table_from_PseudoAction( tmp, pa );
tmp->next = gactions;
tmp->num_effects = pa->num_effects;
gactions = tmp;
gnum_actions++;
had_hard_template[i] = TRUE;
}
}
free( had_hard_template );
gnum_pp_facts = gnum_initial + gnum_relevant_facts;
if ( gcmd_line.display_info == 118 ) {
printf("\nreachability analysys came up with:");
printf("\n\npossibly positive facts:");
for ( f = ginitial; f; f = f->next ) {
printf("\n");
print_Fact( f->fact );
}
for ( i = 0; i < gnum_relevant_facts; i++ ) {
printf("\n");
print_Fact( &(grelevant_facts[i]) );
}
printf("\n\nthis yields these %d action templates:", gnum_actions);
for ( i = 0; i < gnum_operators; i++ ) {
printf("\n\noperator %s:", goperators[i]->name);
for ( a = gactions; a; a = a->next ) {
if ( ( a->norm_operator &&
a->norm_operator->operator != goperators[i] ) ||
( a->pseudo_action &&
a->pseudo_action->operator != goperators[i] ) ) {
continue;
}
printf("\ntemplate: ");
for ( j = 0; j < goperators[i]->number_of_real_params; j++ ) {
printf("%s", gconstants[a->name_inst_table[j]]);
if ( j < goperators[i]->num_vars-1 ) {
printf(" ");
}
}
}
}
printf("\n\n");
}
}
void print_PseudoAction( PseudoAction *o )
{
PseudoActionEffect *e;
int i, m;
printf("\n\n----------------Pseudo Action %s--------------\n",
o->operator->name);
for ( i = 0; i < o->operator->num_vars; i++ ) {
printf("\nx%d = %s of type ", i, gconstants[o->inst_table[i]]);
print_type( o->operator->var_types[i] );
}
printf("\nPreconds:\n");
for ( i = 0; i < o->num_preconds; i++ ) {
print_Fact( &(o->preconds[i]) );
printf("\n");
}
for ( i = 0; i < o->num_numeric_preconds; i++ ) {
switch ( o->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 mixedpre %d\n\n",
o->numeric_preconds_comp[i]);
exit( 1 );
}
print_ExpNode( o->numeric_preconds_lh[i] );
print_ExpNode( o->numeric_preconds_rh[i] );
printf(")\n");
}
m = 0;
printf("\n\nEffects:");
for ( e = o->effects; e; e = e->next ) {
printf("\n\neffect %d", m++);
printf("\n\nConditions\n");
for ( i = 0; i < e->num_conditions; i++ ) {
print_Fact( &(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_Fact( &(e->adds[i]) );
printf("\n");
}
printf("\nDels\n");
for ( i = 0; i < e->num_dels; i++ ) {
print_Fact( &(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 );
}
print_Fluent( &(e->numeric_effects_fluent[i]) );
print_ExpNode( e->numeric_effects_rh[i] );
}
}
}
void RPG_print( void )
{
RPGlayer *t;
RPGfact *p;
RPGvalue *v;
RPGvaluetuple *vt;
RPGaction *a;
RPGeffect *e;
RPGactionlist *al;
RPGeffectlist *el;
int i, j;
printf("\n\nRPG:");
for ( t = gRPG->next; t; t = t->next ) {
printf("\n\nLayer %d:", t->t);
printf("\nFacts bits:");
for ( i = 0; i < gnum_relevant_facts; i++ ) {
if ( t->is_P[i] ) {
printf(" %3d", i);
} else {
printf(" ");
}
}
printf("\nFacts:");
for ( p = t->P->next; p; p = p->next ) {
printf(" (%d: ", p->id);
print_Fact(p->p);
printf(")");
}
printf("\nFluents:");
for ( i = 0; i < gnum_relevant_fluents; i++ ) {
printf("\n%d: ", i);
print_Fluent(&(grelevant_fluents[i]));
printf(":");
for ( v = t->V[i]->next; v; v = v->next ) {
printf(" %.2f", v->v);
}
}
if ( gcmd_line.debug && gcmd_line.dRPG ) {
printf("\nConstraint tuples:");
for ( i = 0; i < gnum_relevant_constraints; i++ ) {
printf("\n%d: ", i);
for ( vt = t->constraint_VT[i]->next; vt; vt = vt->next ) {
printf("\n");
for ( j = 0; j < gnum_relevant_fluents; j++ ) {
if ( vt->have[j] ) {
printf("%6.2f ", vt->vt[j]);
} else {
printf(" ");
}
}
}
}
printf("\nPsi tuples:");
for ( i = 0; i < gnum_relevant_psis; i++ ) {
printf("\n%d: ", i);
for ( vt = t->psi_VT[i]->next; vt; vt = vt->next ) {
printf("\n");
for ( j = 0; j < gnum_relevant_fluents; j++ ) {
if ( vt->have[j] ) {
printf("%6.2f ", vt->vt[j]);
} else {
printf(" ");
}
}
}
}
}
/* in the last layer built, there are no actions.
*/
if ( t->A ) {
printf("\nActions:");
for ( a = t->A->next; a; a = a->next ) {
printf("\n%d: ", a->id);
print_Action_name(a->a);
printf(":");
for ( e = a->E->next; e; e = e->next ) {
printf(" %d", e->id);
}
}
/* connectivity info, for debugging...
*/
if ( gcmd_line.debug && gcmd_line.dRPG ) {
printf("\n\nConnectivity:");
printf("\nFacts:");
for ( i = 0; i < gnum_relevant_facts; i++ ) {
printf("\n\n");
print_Fact(&(grelevant_facts[i]));
/* added by:
*/
printf("\nAdders: ");
for ( el = t->tA[i]->next; el; el = el->next ) {
for ( a = t->A->next; a; a = a->next ) {
j = 0;
for ( e = a->E->next; e; e = e->next ) {
if ( e == el->e ) {
break;
}
j++;
}
if ( e ) {
break;
}
}
if ( !a ) {
printf("\ndidn't find action to effect, print RPG tA?\n\n");
exit( 1 );
}
print_Action_name(a->a);
printf("-eff%d, ", j);
}
/* deleted by:
*/
printf("\nDeleters: ");
for ( el = t->tD[i]->next; el; el = el->next ) {
for ( a = t->A->next; a; a = a->next ) {
j = 0;
for ( e = a->E->next; e; e = e->next ) {
if ( e == el->e ) {
break;
}
j++;
}
if ( e ) {
break;
}
}
if ( !a ) {
printf("\ndidn't find action to effect, print RPG tD?\n\n");
exit( 1 );
}
print_Action_name(a->a);
printf("-eff%d, ", j);
}
/* in con of:
*/
printf("\nIn condition of: ");
for ( el = t->tC[i]->next; el; el = el->next ) {
for ( a = t->A->next; a; a = a->next ) {
j = 0;
for ( e = a->E->next; e; e = e->next ) {
if ( e == el->e ) {
break;
}
j++;
}
if ( e ) {
break;
}
}
if ( !a ) {
printf("\ndidn't find action to effect, print RPG tC?\n\n");
exit( 1 );
}
print_Action_name(a->a);
printf("-eff%d, ", j);
}
/* in pre of:
*/
printf("\nIn precond of: ");
for ( al = t->tP[i]->next; al; al = al->next ) {
print_Action_name(al->a->a);
printf(", ");
}
} /* endfor i over fact indices */
printf("\nFluents:");
for ( i = 0; i < gnum_relevant_fluents; i++ ) {
printf("\n\n");
print_Fluent(&(grelevant_fluents[i]));
/* affected by:
*/
printf("\nAffected by: ");
for ( el = t->tXA[i]->next; el; el = el->next ) {
for ( a = t->A->next; a; a = a->next ) {
j = 0;
for ( e = a->E->next; e; e = e->next ) {
if ( e == el->e ) {
break;
}
j++;
}
if ( e ) {
break;
}
}
if ( !a ) {
printf("\ndidn't find action to effect, print RPG tXA?\n\n");
exit( 1 );
}
print_Action_name(a->a);
printf("-eff%d, ", j);
}
/* in con \cup efrhs of:
*/
printf("\nIn con or eff rhs of: ");
for ( el = t->tXC[i]->next; el; el = el->next ) {
for ( a = t->A->next; a; a = a->next ) {
j = 0;
for ( e = a->E->next; e; e = e->next ) {
if ( e == el->e ) {
break;
}
j++;
}
if ( e ) {
break;
}
}
if ( !a ) {
printf("\ndidn't find action to effect, print RPG tXC?\n\n");
exit( 1 );
}
print_Action_name(a->a);
printf("-eff%d, ", j);
}
/* in con \cup efrhs of:
*/
printf("\nIn pre of: ");
for ( al = t->tXP[i]->next; al; al = al->next ) {
print_Action_name(al->a->a);
printf(", ");
}
} /* endfor i over fluent indices */
} /* endif debug */
} /* endif there is an action layer */
} /* endfor t over layers */
fflush(stdout);
}
void perform_reachability_analysis( void )
{
int size, i, j, k, adr, num;
Bool fixpoint;
Facts *f;
NormOperator *no;
EasyTemplate *t1, *t2;
NormEffect *ne;
Action *tmp, *a;
Bool *had_hard_template;
PseudoAction *pa;
PseudoActionEffect *pae;
/*
* DEA - University of Brescia
*/
int numero, kk, kkk;
WffNode *precs, *n;
/*
* End of DEA
*/
gactions = NULL;
gnum_actions = 0;
for ( i = 0; i < gnum_predicates; i++ ) {
size = 1;
for ( j = 0; j < garity[i]; j++ ) {
size *= gnum_constants;
}
lpos[i] = ( int_pointer ) calloc( size, sizeof( int ) );
lneg[i] = ( int_pointer ) calloc( size, sizeof( int ) );
luse[i] = ( int_pointer ) calloc( size, sizeof( int ) );
lindex[i] = ( int_pointer ) calloc( size, sizeof( int ) );
for ( j = 0; j < size; j++ ) {
lpos[i][j] = 0;
lneg[i][j] = 1;/* all facts but initials are poss. negative */
luse[i][j] = 0;
lindex[i][j] = -1;
}
}
had_hard_template = ( Bool * ) calloc( gnum_hard_templates, sizeof( Bool ) );
for ( i = 0; i < gnum_hard_templates; i++ ) {
had_hard_template[i] = FALSE;
}
/* mark initial facts as possibly positive, not poss. negative
*/
for ( i = 0; i < gnum_predicates; i++ ) {
lp = i;
for ( j = 0; j < gnum_initial_predicate[i]; j++ ) {
for ( k = 0; k < garity[i]; k++ ) {
largs[k] = ginitial_predicate[i][j].args[k];
}
adr = fact_adress();
lpos[lp][adr] = 1;
lneg[lp][adr] = 0;
}
}
/* compute fixpoint
*/
fixpoint = FALSE;
while ( !fixpoint ) {
fixpoint = TRUE;
/*
* DEA - University of Brescia
*/
/*geasy_templates: action list (instantious operator)
*/
numero = 0;
for (t1 = geasy_templates; t1; t1 = t1->next)
numero++;
if (gcmd_line.display_info == 121)
printf ("\nLe geasy_templates sono %d, le gnum_actions %d", numero, gnum_actions);
/*
* End of DEA
*/
/* assign next layer of easy templates to possibly positive fixpoint
*/
t1 = geasy_templates;
while ( t1 ) {
no = t1->op;
for ( i = 0; i < no->num_preconds; i++ ) {
lp = no->preconds[i].predicate;
for ( j = 0; j < garity[lp]; j++ ) {
largs[j] = ( no->preconds[i].args[j] >= 0 ) ?
no->preconds[i].args[j] : t1->inst_table[DECODE_VAR( no->preconds[i].args[j] )];
}
/*
* DEA - University of Brescia
*/
//se questa precondizione compare anche tra gli effetti additivi, allora considerala raggiunta
//ATTENZIONE: non e' esattamente corretto; questo check e' volto a gestire il caso di una precondizione over all o at end
//che viene realizzata attraverso un effetto at start - senza qs check l'azione non risulta applicabile
//il problema e' che qui non introduco i check su overall, end, etc: basta che una preco compaia anche tra gli effetti e la considero raggiunta
//ATTENZIONE: saltare questo check se il corrispondente PlOperator e' is_odd
for (kk = 0; kk < no->effects->num_adds; kk++)
{
int this_pred = no->effects->adds[kk].predicate;
if(no->effects->num_adds>MAX_VARS)
{
#ifdef __MY_OUTPUT__
MSG_ERROR ( WAR_MAX_VARS );
#else
printf( WAR_MAX_VARS );
#endif
exit (1);
}
for (kkk = 0; kkk < no->effects->num_adds; kkk++)
these_args[kkk] = (no->effects->adds[kk].args[kkk] >= 0) ?
no->effects->adds[kk].args[kkk] : t1->
inst_table[DECODE_VAR(no->effects->adds[kk].args[kkk])];
//cerco la preco corrente tra gli effetti additivi
//il predicato non coincide: provo con il prossimo effetto
if (this_pred != lp)
continue;
//controllo tutti gli argomenti
for (kkk = 0; kkk < garity[this_pred]; kkk++)
//se ce n'e' almeno uno diverso, non e' lo stesso fatto
if (these_args[kkk] != largs[kkk])
break;
//questo if e' vero se e' lo stesso fatto: l'ho trovato quindi esco
if (kkk == garity[this_pred])
break;
}
//se non ho fatto passare tutti gli effetti, significa che ho trovato la preco tra gli effetti additivi: considero raggiunta la preco, passa a controllare la prossima
if (kk != no->effects->num_adds)
continue;
/* se tale preco non e' raggiunta, esci e vai a qui1 */
/*
* End of DEA
*/
if ( !lpos[lp][fact_adress()] ) {
break;
}
}
if ( i < no->num_preconds ) {
t1 = t1->next;
continue;
}
/*
* DEA - University of Brescia
*/
//ulteriore check: verifico che un predicato inerziale sia effettivamente presente nei fatti iniziali, altrimenti l'azione non e' applicabile
//problema rilevato con Rovers/SimpleTime
precs = no->operator-> preconds;
if (precs->connective == AND)
precs = precs->sons;
for (n = precs; n; n = n->next)
{
//mi e' capitato di trovare un nodo not, con son predicato -1. boh? (problema:Satellite/numeric)
if (n->fact == NULL)
continue;
/*lp=numero di predicato della preco i-esima */
lp = n->fact->predicate;
/*per ciascuno degli argomenti della precondizione */
for (j = 0; j < garity[lp]; j++)
{
/* CONTROLLARE */
largs[j] =(n->fact->args[j] >= 0 ) ? n->fact->args[j]: t1->inst_table[DECODE_VAR (n->fact->args[j])];
}
adr = fact_adress ();
//CHECK1 chiesto da Ivan: se il fatto e' non inerziale e non compare tra le preconds del normoperator, da errore!
//INIZIO CHECK1
if (gis_added[lp] || gis_deleted[lp])
{
for (i = 0; i < no->num_preconds; i++)
{
/*lp=numero di predicato della preco i-esima */
lp1 = no->preconds[i].predicate;
/*per ciascuno degli argomenti della precondizione */
for (j = 0; j < garity[lp1]; j++)
{
/* non ho colto qui perche' ci sono 2 casi, comunque mette in largs[k] il numero di ciascun oggetto */
largs1[j] = (no->preconds[i].args[j] >= 0) ?
no->preconds[i].args[j] : t1->
inst_table[DECODE_VAR (no->preconds[i].args[j])];
}
if ((lp == lp1) && (adr == fact_adress1 ()))
break;
}
if (i == no->num_preconds)
{
if(DEBUG3)
{
printf ("\nAttenzione: uno dei fatti non inerziali non compare tra le preconds del normoperator!\n");
fflush (stdout);
}
assert (0);
}
}
//FINE CHECK1
//se questo fatto viene aggiunto, non e' necessario verificarlo -> passo al prossimo
if (gis_added[lp])
continue;
//Se il fatto non e' stato raggiunto, non posso applicare l'azione: esco dal for
if (!lpos[lp][fact_adress ()])
break;
}
//se ho fatto un break prima di finire le preco, significa che un predicato inerziale non compare nei fatti iniziali
if (n != NULL)
{
//passo quindi ad esaminare la prossima azione
t1 = t1->next;
continue;
}
/*
* End of DEA
*/
num = 0;
for ( ne = no->effects; ne; ne = ne->next ) {
num++;
/* currently, simply ignore effect conditions and assume
* they will all be made true eventually.
*/
for ( i = 0; i < ne->num_adds; i++ ) {
lp = ne->adds[i].predicate;
for ( j = 0; j < garity[lp]; j++ ) {
largs[j] = ( ne->adds[i].args[j] >= 0 ) ?
ne->adds[i].args[j] : t1->inst_table[DECODE_VAR( ne->adds[i].args[j] )];
}
adr = fact_adress();
if ( !lpos[lp][adr] ) {
/* new relevant fact! (added non initial)
*/
lpos[lp][adr] = 1;
lneg[lp][adr] = 1;
luse[lp][adr] = 1;
if ( gnum_relevant_facts == MAX_RELEVANT_FACTS ) {
printf("\ntoo many relevant facts! increase MAX_RELEVANT_FACTS (currently %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++;
fixpoint = FALSE;
}
}
}
/*
* DEA - University of Brescia
*/
check_time_and_length (0); /* con zero non controlla la lunghezza */
/*
* End of DEA
*/
tmp = new_Action();
tmp->norm_operator = no;
for ( i = 0; i < no->num_vars; i++ ) {
tmp->inst_table[i] = t1->inst_table[i];
}
tmp->name = no->operator->name;
tmp->num_name_vars = no->operator->number_of_real_params;
make_name_inst_table_from_NormOperator( tmp, no, t1 );
tmp->next = gactions;
tmp->num_effects = num;
gactions = tmp;
gnum_actions++;
t2 = t1->next;
if ( t1->next ) {
t1->next->prev = t1->prev;
}
if ( t1->prev ) {
t1->prev->next = t1->next;
} else {
geasy_templates = t1->next;
}
free_single_EasyTemplate( t1 );
t1 = t2;
}
/* now assign all hard templates that have not been transformed
* to actions yet.
*/
for ( i = 0; i < gnum_hard_templates; i++ ) {
if ( had_hard_template[i] ) {
continue;
}
pa = ghard_templates[i];
for ( j = 0; j < pa->num_preconds; j++ ) {
lp = pa->preconds[j].predicate;
for ( k = 0; k < garity[lp]; k++ ) {
largs[k] = pa->preconds[j].args[k];
}
if ( !lpos[lp][fact_adress()] ) {
break;
}
}
if ( j < pa->num_preconds ) {
continue;
}
for ( pae = pa->effects; pae; pae = pae->next ) {
/* currently, simply ignore effect conditions and assume
* they will all be made true eventually.
*/
for ( j = 0; j < pae->num_adds; j++ ) {
lp = pae->adds[j].predicate;
for ( k = 0; k < garity[lp]; k++ ) {
largs[k] = pae->adds[j].args[k];
}
adr = fact_adress();
if ( !lpos[lp][adr] ) {
/* new relevant fact! (added non initial)
*/
lpos[lp][adr] = 1;
lneg[lp][adr] = 1;
luse[lp][adr] = 1;
if ( gnum_relevant_facts == MAX_RELEVANT_FACTS ) {
printf("\ntoo many relevant facts! increase MAX_RELEVANT_FACTS (currently %d)\n\n",
MAX_RELEVANT_FACTS);
exit( 1 );
}
grelevant_facts[gnum_relevant_facts].predicate = lp;
for ( k = 0; k < garity[lp]; k++ ) {
grelevant_facts[gnum_relevant_facts].args[k] = largs[k];
}
lindex[lp][adr] = gnum_relevant_facts;
gnum_relevant_facts++;
fixpoint = FALSE;
}
}
}
/*
* DEA - University of Brescia
*/
check_time_and_length (0); /* con zero non controlla la lunghezza */
/*
* End of DEA
*/
tmp = new_Action();
tmp->pseudo_action = pa;
for ( j = 0; j < pa->operator->num_vars; j++ ) {
tmp->inst_table[j] = pa->inst_table[j];
}
tmp->name = pa->operator->name;
tmp->num_name_vars = pa->operator->number_of_real_params;
make_name_inst_table_from_PseudoAction( tmp, pa );
tmp->next = gactions;
tmp->num_effects = pa->num_effects;
gactions = tmp;
gnum_actions++;
had_hard_template[i] = TRUE;
}
}
/*
* DEA - University of Brescia
*/
numero = 0;
for (t1 = geasy_templates; t1; t1 = t1->next)
numero++;
if (gcmd_line.display_info == 121)
printf ("\nLe geasy_templates sono %d, le gnum_actions %d", numero, gnum_actions);
/*
* End of DEA
*/
free( had_hard_template );
gnum_pp_facts = gnum_initial + gnum_relevant_facts;
if ( gcmd_line.display_info == 118 ) {
printf("\nreachability analysys came up with:");
printf("\n\npossibly positive facts:");
for ( f = ginitial; f; f = f->next ) {
printf("\n");
print_Fact( f->fact );
}
for ( i = 0; i < gnum_relevant_facts; i++ ) {
printf("\n");
print_Fact( &(grelevant_facts[i]) );
}
printf("\n\nthis yields these %d action templates:", gnum_actions);
for ( i = 0; i < gnum_operators; i++ ) {
printf("\n\noperator %s:", goperators[i]->name);
for ( a = gactions; a; a = a->next ) {
if ( ( a->norm_operator &&
a->norm_operator->operator != goperators[i] ) ||
( a->pseudo_action &&
a->pseudo_action->operator != goperators[i] ) ) {
continue;
}
printf("\ntemplate: ");
for ( j = 0; j < goperators[i]->number_of_real_params; j++ ) {
printf("%s", gconstants[a->name_inst_table[j]]);
if ( j < goperators[i]->num_vars-1 ) {
printf(" ");
}
}
}
}
printf("\n\n");
}
}
