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; } }