void unify_easy_inertia_preconds( int curr_inertia )
{
int p, i, j, af, hh;
int args[MAX_VARS];
int affected_params[MAX_VARS];
int num_affected_params = 0;
if ( curr_inertia == lnum_inertia_conds ) {
multiply_easy_non_constrained_op_parameters( 0 );
return;
}
p = lo->preconds[linertia_conds[curr_inertia]].predicate;
for ( i = 0; i < garity[p]; i++ ) {
args[i] = lo->preconds[linertia_conds[curr_inertia]].args[i];
if ( args[i] < 0 ) {
hh = DECODE_VAR( args[i] );
if ( lo->inst_table[hh] != -1 ) {
args[i] = lo->inst_table[hh];
} else {
affected_params[num_affected_params++] = hh;
}
}
}
for ( i = 0; i < gnum_initial_predicate[p]; i++ ) {
af = 0;
for ( j = 0; j < garity[p]; j++ ) {
if ( args[j] >= 0 ) {
if ( args[j] != ginitial_predicate[p][i].args[j] ) {
break;
} else {
continue;
}
}
/* check whether that constant has the correct type for that
* parameter (can be not fulfilled due to encoding of unary inertia
*/
if ( !gis_member[ginitial_predicate[p][i].args[j]][lo->var_types[affected_params[af]]] ) {
break;
}
/* legal constant; set op parameter instantiation to it
*/
lo->inst_table[affected_params[af++]] = ginitial_predicate[p][i].args[j];
}
if ( j < garity[p] ) {
continue;
}
unify_easy_inertia_preconds( curr_inertia + 1 );
}
for ( i = 0; i < num_affected_params; i++ ) {
lo->inst_table[affected_params[i]] = -1;
}
}
void multiply_easy_non_constrained_op_parameters( int curr_parameter )
{
EasyTemplate *tmp;
int i, j, t, n;
if ( curr_parameter == lnum_multiply_parameters ) {
tmp = new_EasyTemplate( lo );
for ( i = 0; i < lo->num_vars; i++ ) {
tmp->inst_table[i] = lo->inst_table[i];
}
tmp->next = geasy_templates;
if ( geasy_templates ) {
geasy_templates->prev = tmp;
}
geasy_templates = tmp;
gnum_easy_templates++;
return;
}
if ( curr_parameter == lnum_multiply_parameters - 1 ) {
t = lo->var_types[lmultiply_parameters[curr_parameter]];
n = gtype_size[t];
for ( i = 0; i < n; i++ ) {
lo->inst_table[lmultiply_parameters[curr_parameter]] = gtype_consts[t][i];
tmp = new_EasyTemplate( lo );
for ( j = 0; j < lo->num_vars; j++ ) {
tmp->inst_table[j] = lo->inst_table[j];
}
tmp->next = geasy_templates;
if ( geasy_templates ) {
geasy_templates->prev = tmp;
}
geasy_templates = tmp;
gnum_easy_templates++;
}
lo->inst_table[lmultiply_parameters[curr_parameter]] = -1;
return;
}
t = lo->var_types[lmultiply_parameters[curr_parameter]];
n = gtype_size[t];
for ( i = 0; i < n; i++ ) {
lo->inst_table[lmultiply_parameters[curr_parameter]] = gtype_consts[t][i];
multiply_easy_non_constrained_op_parameters( curr_parameter + 1 );
}
lo->inst_table[lmultiply_parameters[curr_parameter]] = -1;
}
void multiply_easy_non_constrained_op_parameters( int curr_parameter )
{
EasyTemplate *tmp;
int i, j, t, n;
if ( curr_parameter == lnum_multiply_parameters ) {
tmp = new_EasyTemplate( lo );
for ( i = 0; i < lo->num_vars; i++ ) {
tmp->inst_table[i] = lo->inst_table[i];
}
tmp->next = geasy_templates;
if ( geasy_templates ) {
geasy_templates->prev = tmp;
}
geasy_templates = tmp;
gnum_easy_templates++;
return;
}
if ( curr_parameter == lnum_multiply_parameters - 1 ) {
t = lo->var_types[lmultiply_parameters[curr_parameter]];
n = gtype_size[t];
for ( i = 0; i < n; i++ ) {
/*
if ( lused_constant[gtype_consts[t][i]] ) {
if (GpG.inst_duplicate_param == FALSE)
continue;
}
*/
lo->inst_table[lmultiply_parameters[curr_parameter]] = gtype_consts[t][i];
tmp = new_EasyTemplate( lo );
for ( j = 0; j < lo->num_vars; j++ ) {
tmp->inst_table[j] = lo->inst_table[j];
}
tmp->next = geasy_templates;
if ( geasy_templates ) {
geasy_templates->prev = tmp;
}
geasy_templates = tmp;
gnum_easy_templates++;
}
lo->inst_table[lmultiply_parameters[curr_parameter]] = -1;
return;
}
t = lo->var_types[lmultiply_parameters[curr_parameter]];
n = gtype_size[t];
for ( i = 0; i < n; i++ ) {
/*
if ( lused_constant[gtype_consts[t][i]] ) {
continue;
}
*/
lo->inst_table[lmultiply_parameters[curr_parameter]] = gtype_consts[t][i];
lused_constant[gtype_consts[t][i]] = TRUE;
multiply_easy_non_constrained_op_parameters( curr_parameter + 1 );
lused_constant[gtype_consts[t][i]] = FALSE;
}
lo->inst_table[lmultiply_parameters[curr_parameter]] = -1;
}
void unify_easy_inertia_preconds( int curr_inertia )
{
int p, i, j, k, af, hh;
int args[MAX_VARS];
int affected_params[MAX_VARS];
int num_affected_params = 0;
if ( curr_inertia == lnum_inertia_conds ) {
multiply_easy_non_constrained_op_parameters( 0 );
return;
}
p = lo->preconds[linertia_conds[curr_inertia]].predicate;
for ( i = 0; i < garity[p]; i++ ) {
args[i] = lo->preconds[linertia_conds[curr_inertia]].args[i];
if ( args[i] < 0 ) {
hh = DECODE_VAR( args[i] );
if ( lo->inst_table[hh] != -1 ) {
args[i] = lo->inst_table[hh];
} else {
affected_params[num_affected_params++] = hh;
}
}
}
for ( i = 0; i < gnum_initial_predicate[p]; i++ ) {
af = 0;
for ( j = 0; j < garity[p]; j++ ) {
if ( args[j] >= 0 ) {
if ( args[j] != ginitial_predicate[p][i].args[j] ) {
break;
} else {
continue;
}
}
/* see if we have that constant already in instantiation;
* if so, skip this inertia: op params are assumed different!
*/
/*
if ( lused_constant[ginitial_predicate[p][i].args[j]] ) {
break;
}
*/
/* legal constant; set op parameter instantiation to it
*/
lo->inst_table[affected_params[af++]] = ginitial_predicate[p][i].args[j];
lused_constant[ginitial_predicate[p][i].args[j]] = TRUE;
}
if ( j < garity[p] ) {
for ( k = 0; k < af; k++ ) {
lused_constant[lo->inst_table[affected_params[k]]] = FALSE;
}
continue;
}
unify_easy_inertia_preconds( curr_inertia + 1 );
for ( j = 0; j < num_affected_params; j++ ) {
lused_constant[lo->inst_table[affected_params[j]]] = FALSE;
}
}
for ( i = 0; i < num_affected_params; i++ ) {
lo->inst_table[affected_params[i]] = -1;
}
}
