void cleanup_easy_domain( void )
{
int i, i1, i2, i3, i4, a;
NormOperator *o;
NormEffect *e;
/* most likely ( for sure ? ) we do not need this function call here,
* as empty types are recognised in translation already.
*
* however, who knows .. ? doesn't need any real computation time anyway.
*
* function DOES make sense after unaries encoding, as artificial types
* might well be empty.
*/
handle_empty_easy_parameters();
/* remove identical preconds and effects;
* VERY unlikely that such will get down to here, after all
* the formula preprocessing, but possible (?) in principle.
* takes no computation time.
*
* also, remove effect conditions that are contained in the
* preconditions.
*/
for ( i = 0; i < gnum_easy_operators; i++ ) {
o = geasy_operators[i];
i1 = 0;
while ( i1 < o->num_preconds-1 ) {
i2 = i1+1;
while ( i2 < o->num_preconds ) {
if ( identical_fact( &(o->preconds[i1]), &(o->preconds[i2]) ) ) {
for ( i3 = i2; i3 < o->num_preconds-1; i3++ ) {
o->preconds[i3].predicate = o->preconds[i3+1].predicate;
for ( i4 = 0; i4 < garity[o->preconds[i3].predicate]; i4++ ) {
o->preconds[i3].args[i4] = o->preconds[i3+1].args[i4];
}
}
o->num_preconds--;
} else {
i2++;
}
}
i1++;
}
for ( e = o->effects; e; e = e->next ) {
i1 = 0;
while ( i1 < e->num_conditions-1 ) {
i2 = i1+1;
while ( i2 < e->num_conditions ) {
if ( identical_fact( &(e->conditions[i1]), &(e->conditions[i2]) ) ) {
for ( i3 = i2; i3 < e->num_conditions-1; i3++ ) {
e->conditions[i3].predicate = e->conditions[i3+1].predicate;
/* here, we can still have equalities. nowhere else.
*/
a = ( e->conditions[i3].predicate < 0 ) ?
2 : garity[e->conditions[i3].predicate];
for ( i4 = 0; i4 < a; i4++ ) {
e->conditions[i3].args[i4] = e->conditions[i3+1].args[i4];
}
}
e->num_conditions--;
} else {
i2++;
}
}
i1++;
}
i1 = 0;
while ( i1 < e->num_conditions ) {
for ( i2 = 0; i2 < o->num_preconds; i2++ ) {
if ( identical_fact( &(e->conditions[i1]), &(o->preconds[i2]) ) ) {
break;
}
}
if ( i2 == o->num_preconds ) {
i1++;
continue;
}
for ( i2 = i1; i2 < e->num_conditions-1; i2++ ) {
e->conditions[i2].predicate = e->conditions[i2+1].predicate;
for ( i3 = 0; i3 < garity[e->conditions[i2].predicate]; i3++ ) {
e->conditions[i2].args[i3] = e->conditions[i2+1].args[i3];
}
}
e->num_conditions--;
}
i1 = 0;
while ( i1 < e->num_adds-1 ) {
i2 = i1+1;
while ( i2 < e->num_adds ) {
if ( identical_fact( &(e->adds[i1]), &(e->adds[i2]) ) ) {
for ( i3 = i2; i3 < e->num_adds-1; i3++ ) {
e->adds[i3].predicate = e->adds[i3+1].predicate;
for ( i4 = 0; i4 < garity[e->adds[i3].predicate]; i4++ ) {
e->adds[i3].args[i4] = e->adds[i3+1].args[i4];
}
}
e->num_adds--;
} else {
i2++;
}
}
i1++;
}
i1 = 0;
while ( i1 < e->num_dels-1 ) {
i2 = i1+1;
while ( i2 < e->num_dels ) {
if ( identical_fact( &(e->dels[i1]), &(e->dels[i2]) ) ) {
for ( i3 = i2; i3 < e->num_dels-1; i3++ ) {
e->dels[i3].predicate = e->dels[i3+1].predicate;
for ( i4 = 0; i4 < garity[e->dels[i3].predicate]; i4++ ) {
e->dels[i3].args[i4] = e->dels[i3+1].args[i4];
}
}
e->num_dels--;
} else {
i2++;
}
}
i1++;
}
}
}
}
void encode_easy_unaries_as_types( void )
{
NormOperator *o;
int i1, i, j, k, l, new_T, p, a;
TypeArray T;
int num_T;
NormEffect *e;
int intersected_type, var;
for ( i1 = 0; i1 < gnum_easy_operators; i1++ ) {
o = geasy_operators[i1];
for ( i = 0; i < o->num_vars; i++ ) {
T[0] = o->var_types[i];
num_T = 1;
j = 0;
while ( j < o->num_preconds ) {
p = o->preconds[j].predicate;
if ( ( (new_T = gtype_to_predicate[p]) != -1 ) &&
( o->preconds[j].args[0] == ENCODE_VAR( i ) ) ) {
if ( num_T == MAX_TYPE_INTERSECTIONS ) {
printf("\nincrease MAX_TYPE_INTERSECTIONS (currently %d)\n\n",
MAX_TYPE_INTERSECTIONS);
exit( 1 );
}
/* insert new type number into ordered array T;
* ---- all type numbers in T are different:
* new nr. is of inferred type - can't be type declared for param
* precondition facts occur at most once - doubles are removed
* during cleanup
*/
for ( k = 0; k < num_T; k++ ) {
if ( new_T < T[k] ) {
break;
}
}
for ( l = num_T; l > k; l-- ) {
T[l] = T[l-1];
}
T[k] = new_T;
num_T++;
/* now remove superfluous precondition
*/
for ( k = j; k < o->num_preconds-1; k++ ) {
o->preconds[k].predicate = o->preconds[k+1].predicate;
for ( l = 0; l < garity[o->preconds[k].predicate]; l++ ) {
o->preconds[k].args[l] = o->preconds[k+1].args[l];
}
}
o->num_preconds--;
} else {
j++;
}
}
/* if we did not hit any unary inertia concerning this parameter
* in the preconds, skip parameter and go to next one
*/
if ( num_T == 1 ) {
continue;
}
/* now we have the ordered array of types to intersect for param i
* of op o in array T of size num_T;
* if there already is this intersected type, set type of this
* param to its number, otherwise create the new intersected type.
*/
if ( (intersected_type = find_intersected_type( T, num_T )) != -1 ) {
/* type already there
*/
o->var_types[i] = intersected_type;
continue;
}
/* create new type
*/
o->var_types[i] = create_intersected_type( T, num_T );
}
for ( e = o->effects; e; e = e->next ) {
for ( i = 0; i < e->num_vars; i++ ) {
T[0] = e->var_types[i];
var = o->num_vars + i;
num_T = 1;
j = 0;
while ( j < e->num_conditions ) {
p = e->conditions[j].predicate;
if ( p < 0 ) {
j++;
continue;
}
if ( ( (new_T = gtype_to_predicate[p]) != -1 ) &&
( e->conditions[j].args[0] == ENCODE_VAR( var ) ) ) {
if ( num_T == MAX_TYPE_INTERSECTIONS ) {
printf("\nincrease MAX_TYPE_INTERSECTIONS (currently %d)\n\n",
MAX_TYPE_INTERSECTIONS);
exit( 1 );
}
for ( k = 0; k < num_T; k++ ) {
if ( new_T < T[k] ) {
break;
}
}
for ( l = num_T; l > k; l-- ) {
T[l] = T[l-1];
}
T[k] = new_T;
num_T++;
for ( k = j; k < e->num_conditions-1; k++ ) {
e->conditions[k].predicate = e->conditions[k+1].predicate;
a = ( e->conditions[k].predicate < 0 ) ?
2 : garity[e->conditions[k].predicate];
for ( l = 0; l < a; l++ ) {
e->conditions[k].args[l] = e->conditions[k+1].args[l];
}
}
e->num_conditions--;
} else {
j++;
}
}
if ( num_T == 1 ) {
continue;
}
if ( (intersected_type = find_intersected_type( T, num_T )) != -1 ) {
e->var_types[i] = intersected_type;
continue;
}
e->var_types[i] = create_intersected_type( T, num_T );
}
}
}
handle_empty_easy_parameters();
}
void cleanup_easy_domain( void )
{
int i, i1, sw, i2, i3, i4, a;
NormOperator *o;
NormEffect *e;
/* remove equality constraints in preconditions
* (op params are assumed different)
*/
for ( i = 0; i < gnum_easy_operators; i++ ) {
o = geasy_operators[i];
i1 = 0;
while ( i1 < o->num_preconds ) {
if ( o->preconds[i1].predicate == -1 ) {
sw = 0;
if ( o->preconds[i1].args[0] < 0 ) {
sw++;
}
if ( o->preconds[i1].args[1] < 0 ) {
sw++;
}
switch ( sw ) {
case 2:
if ( o->preconds[i1].args[0] == o->preconds[i1].args[1] ) {
break;
}
/* replace higher with lower --> higher gets removed in next cleanup step!
*/
replace_var_entries( o, o->preconds[i1].args[0], o->preconds[i1].args[1] );
break;
case 1:
/* replace param with constant
*/
replace_var_entries( o, o->preconds[i1].args[0], o->preconds[i1].args[1] );
break;
case 0:
printf("\ntwo constants in equality of easy precond. debug me\n\n");
exit( 1 );
}
/* equality precond gets removed anyway.
*/
for ( i2 = i1; i2 < o->num_preconds-1; i2++ ) {
o->preconds[i2].predicate = o->preconds[i2+1].predicate;
for ( i3 = 0; i3 < garity[o->preconds[i2].predicate]; i3++ ) {
o->preconds[i2].args[i3] = o->preconds[i2+1].args[i3];
}
}
o->num_preconds--;
continue;
}
if ( o->preconds[i1].predicate == -2 ) {
/* non equality precond gets removed.
*/
for ( i2 = i1; i2 < o->num_preconds-1; i2++ ) {
o->preconds[i2].predicate = o->preconds[i2+1].predicate;
for ( i3 = 0; i3 < garity[o->preconds[i2].predicate]; i3++ ) {
o->preconds[i2].args[i3] = o->preconds[i2+1].args[i3];
}
}
o->num_preconds--;
continue;
}
i1++;
}
}
/* unused params can result from unary encoding;
* that's why we have an extra function here
*/
remove_unused_easy_parameters();
/* most likely ( for sure ? ) we do not need this function call here,
* as empty types are recognised in translation already.
*
* however, who knows .. ? doesn't need any real computation time anyway.
*
* function DOES make sense after unaries encoding, as artificial types
* might well be empty.
*/
handle_empty_easy_parameters();
/* remove identical preconds and effects;
* VERY unlikely that such will get down to here, after all
* the formula preprocessing, but possible (?) in principle.
* takes no computation time.
*
* also, remove effect conditions that are contained in the
* preconditions.
*/
for ( i = 0; i < gnum_easy_operators; i++ ) {
o = geasy_operators[i];
i1 = 0;
while ( i1 < o->num_preconds-1 ) {
i2 = i1+1;
while ( i2 < o->num_preconds ) {
if ( identical_fact( &(o->preconds[i1]), &(o->preconds[i2]) ) ) {
for ( i3 = i2; i3 < o->num_preconds-1; i3++ ) {
o->preconds[i3].predicate = o->preconds[i3+1].predicate;
for ( i4 = 0; i4 < garity[o->preconds[i3].predicate]; i4++ ) {
o->preconds[i3].args[i4] = o->preconds[i3+1].args[i4];
}
}
o->num_preconds--;
} else {
i2++;
}
}
i1++;
}
for ( e = o->effects; e; e = e->next ) {
i1 = 0;
while ( i1 < e->num_conditions-1 ) {
i2 = i1+1;
while ( i2 < e->num_conditions ) {
if ( identical_fact( &(e->conditions[i1]), &(e->conditions[i2]) ) ) {
for ( i3 = i2; i3 < e->num_conditions-1; i3++ ) {
e->conditions[i3].predicate = e->conditions[i3+1].predicate;
/* here, we can still have equalities. nowhere else.
*/
a = ( e->conditions[i3].predicate < 0 ) ?
2 : garity[e->conditions[i3].predicate];
for ( i4 = 0; i4 < a; i4++ ) {
e->conditions[i3].args[i4] = e->conditions[i3+1].args[i4];
}
}
e->num_conditions--;
} else {
i2++;
}
}
i1++;
}
i1 = 0;
while ( i1 < e->num_conditions ) {
for ( i2 = 0; i2 < o->num_preconds; i2++ ) {
if ( identical_fact( &(e->conditions[i1]), &(o->preconds[i2]) ) ) {
break;
}
}
if ( i2 == o->num_preconds ) {
i1++;
continue;
}
for ( i2 = i1; i2 < e->num_conditions-1; i1++ ) {
e->conditions[i2].predicate = e->conditions[i2+1].predicate;
for ( i3 = 0; i3 < garity[e->conditions[i2].predicate]; i3++ ) {
e->conditions[i2].args[i3] = e->conditions[i2+1].args[i3];
}
}
e->num_conditions--;
}
i1 = 0;
while ( i1 < e->num_adds-1 ) {
i2 = i1+1;
while ( i2 < e->num_adds ) {
if ( identical_fact( &(e->adds[i1]), &(e->adds[i2]) ) ) {
for ( i3 = i2; i3 < e->num_adds-1; i3++ ) {
e->adds[i3].predicate = e->adds[i3+1].predicate;
for ( i4 = 0; i4 < garity[e->adds[i3].predicate]; i4++ ) {
e->adds[i3].args[i4] = e->adds[i3+1].args[i4];
}
}
e->num_adds--;
} else {
i2++;
}
}
i1++;
}
i1 = 0;
while ( i1 < e->num_dels-1 ) {
i2 = i1+1;
while ( i2 < e->num_dels ) {
if ( identical_fact( &(e->dels[i1]), &(e->dels[i2]) ) ) {
for ( i3 = i2; i3 < e->num_dels-1; i3++ ) {
e->dels[i3].predicate = e->dels[i3+1].predicate;
for ( i4 = 0; i4 < garity[e->dels[i3].predicate]; i4++ ) {
e->dels[i3].args[i4] = e->dels[i3+1].args[i4];
}
}
e->num_dels--;
} else {
i2++;
}
}
i1++;
}
}
}
}
