static
Term trm_set_vars_recurse(Term t, char **varnames, int max_vars)
{
if (CONSTANT(t)) {
char *name = sn_to_str(SYMNUM(t));
if (variable_name(name)) {
int i = 0;
while (i < max_vars && varnames[i] != NULL && varnames[i] != name)
i++;
if (i == max_vars)
fatal_error("trm_set_vars_recurse: max_vars");
else {
if (varnames[i] == NULL)
varnames[i] = name;
free_term(t);
t = get_variable_term(i);
}
}
}
else {
int i;
for (i = 0; i < ARITY(t); i++)
ARG(t,i) = trm_set_vars_recurse(ARG(t,i), varnames, max_vars);
}
return t;
} /* trm_set_vars_recurse */
boost::optional< substitution > forward_chaining( const atomic_sentence & sen )
{
for ( const atomic_sentence & se : known_facts )
{
auto ret = unify( se, sen );
if ( ret ) { return ret; }
}
bool have_new_inference = true;
std::set< std::string > var_name = variable_name( );
while ( have_new_inference )
{
have_new_inference = false;
for ( const definite_clause & dc : kb )
{
assert( ! dc.premise.empty( ) );
substitution rename =
rename_variable(
dc.premise.begin( ),
dc.premise.end( ),
[&]( const std::string & v ){ return var_name.count( v ) == 0; },
[]( const std::string & n ){ return n + "_"; } );
have_new_inference = try_infer_forward( dc.premise, dc.conclusion, rename, sen ) || have_new_inference;
auto ret = unify( known_facts.back( ), sen );
if ( ret ) { return ret; }
}
}
return boost::optional< substitution >( );
}
void Plot1DimFoams(TList& foam_list, TMVA::ECellValue cell_value,
const TString& cell_value_description,
TMVA::PDEFoamKernelBase* kernel)
{
// visualize a 1 dimensional PDEFoam via a histogram
TCanvas* canvas = NULL;
TH1D* projection = NULL;
// loop over all foams and draw the histogram
TListIter it(&foam_list);
TPair* fm_pair = NULL; // the (foam, caption) pair
while (fm_pair = (TPair*) it()) {
TMVA::PDEFoam* foam = (TMVA::PDEFoam*) fm_pair->Key();
if (!foam) continue;
TString foam_caption(((TObjString*) fm_pair->Value())->String());
TString variable_name(foam->GetVariableName(0)->String());
canvas = new TCanvas(Form("canvas_%u",foam),
"1-dimensional PDEFoam", 400, 400);
projection = foam->Draw1Dim(cell_value, 100, kernel);
projection->SetTitle(cell_value_description + " of " + foam_caption
+ ";" + variable_name);
projection->Draw();
projection->SetDirectory(0);
canvas->Update();
}
}
char *variable_name (program_t * prog, int idx) {
int i = prog->num_inherited - 1;
int first;
if (i > -1)
first = prog->inherit[i].variable_index_offset + prog->inherit[i].prog->num_variables_total;
else
return prog->variable_table[idx];
if (idx >= first)
return prog->variable_table[idx - first];
while (idx < prog->inherit[i].variable_index_offset)
i--;
return variable_name(prog->inherit[i].prog, idx - prog->inherit[i].variable_index_offset);
}
void render_header(std::ostream& output, const po::variables_map& vm) {
output << "#pragma once" << std::endl;
if (vm.count("namespace"))
output << "namespace " << vm["namespace"].as<std::string>() << " {\n";
if (vm.count("input"))
for (auto& name: vm["input"].as<std::vector<std::string>>())
open_file(name, std::ios::in, [&output,&name](std::fstream& file) {
wrap_string(file, output, variable_name(name));
});
if (vm.count("namespace"))
output << "}\n";
}
/* PUBLIC */
Plist free_vars_term(Term t, Plist vars)
{
if (VARIABLE(t))
fatal_error("free_vars_term, VARIABLE term");
if (ARITY(t) == 0) {
if (variable_name(sn_to_str(SYMNUM(t))) && !tlist_member(t, vars))
vars = plist_append(vars, copy_term(t));
}
else {
int i;
for (i = 0; i < ARITY(t); i++)
vars = free_vars_term(ARG(t,i), vars);
}
return vars;
} /* free_vars_term */
void
f_debug_info (void)
{
svalue_t *arg;
outbuffer_t out;
outbuf_zero(&out);
arg = sp - 1;
switch (arg[0].u.number) {
case 0:
{
int i, flags;
object_t *obj2;
ob = arg[1].u.ob;
flags = ob->flags;
outbuf_addv(&out, "O_HEART_BEAT : %s\n",
flags & O_HEART_BEAT ? "TRUE" : "FALSE");
#ifndef NO_WIZARDS
outbuf_addv(&out, "O_IS_WIZARD : %s\n",
flags & O_IS_WIZARD ? "TRUE" : "FALSE");
#endif
#ifdef NO_ADD_ACTION
outbuf_addv(&out, "O_LISTENER : %s\n",
flags & O_LISTENER ? "TRUE" : "FALSE");
#else
outbuf_addv(&out, "O_ENABLE_COMMANDS : %s\n",
flags & O_ENABLE_COMMANDS ? "TRUE" : "FALSE");
#endif
outbuf_addv(&out, "O_CLONE : %s\n",
flags & O_CLONE ? "TRUE" : "FALSE");
outbuf_addv(&out, "O_VIRTUAL : %s\n",
flags & O_VIRTUAL ? "TRUE" : "FALSE");
outbuf_addv(&out, "O_DESTRUCTED : %s\n",
flags & O_DESTRUCTED ? "TRUE" : "FALSE");
outbuf_addv(&out, "O_ONCE_INTERACTIVE: %s\n",
flags & O_ONCE_INTERACTIVE ? "TRUE" : "FALSE");
outbuf_addv(&out, "O_RESET_STATE : %s\n",
flags & O_RESET_STATE ? "TRUE" : "FALSE");
outbuf_addv(&out, "O_WILL_CLEAN_UP : %s\n",
flags & O_WILL_CLEAN_UP ? "TRUE" : "FALSE");
outbuf_addv(&out, "O_WILL_RESET : %s\n",
flags & O_WILL_RESET ? "TRUE" : "FALSE");
#ifdef HAVE_ZLIB
if (ob->interactive) {
outbuf_addv(&out, "O_COMPRESSED : %s\n",
ob->interactive->compressed_stream ? "TRUE" :
"FALSE");
outbuf_addv(&out, "O_ZMP : %s\n",
ob->interactive->iflags & USING_ZMP ? "TRUE" :
"FALSE");
outbuf_addv(&out, "O_GMCP : %s\n",
ob->interactive->iflags & USING_GMCP ? "TRUE" :
"FALSE");
outbuf_addv(&out, "O_MXP : %s\n",
ob->interactive->iflags & USING_MXP ? "TRUE" :
"FALSE");
}
#endif
#ifndef NO_LIGHT
outbuf_addv(&out, "total light : %d\n", ob->total_light);
#endif
#ifndef NO_RESETS
outbuf_addv(&out, "next_reset : %d\n", ob->next_reset);
#endif
outbuf_addv(&out, "time_of_ref : %d\n", ob->time_of_ref);
outbuf_addv(&out, "ref : %d\n", ob->ref);
#ifdef DEBUG
outbuf_addv(&out, "extra_ref : %d\n", ob->extra_ref);
#endif
outbuf_addv(&out, "name : '/%s'\n", ob->obname);
outbuf_addv(&out, "next_all : OBJ(/%s)\n",
ob->next_all ? ob->next_all->obname : "NULL");
if (obj_list == ob)
outbuf_add(&out, "This object is the head of the object list.\n");
for (obj2 = obj_list, i = 1; obj2; obj2 = obj2->next_all, i++)
if (obj2->next_all == ob) {
outbuf_addv(&out, "Previous object in object list: OBJ(/%s)\n",
obj2->obname);
outbuf_addv(&out, "position in object list:%d\n", i);
}
break;
}
case 1:
ob = arg[1].u.ob;
outbuf_addv(&out, "program ref's %d\n", ob->prog->ref);
outbuf_addv(&out, "Name /%s\n", ob->prog->filename);
outbuf_addv(&out, "program size %d\n",
ob->prog->program_size);
outbuf_addv(&out, "function flags table %d (%d) \n",
ob->prog->last_inherited + ob->prog->num_functions_defined,
(ob->prog->last_inherited + ob->prog->num_functions_defined)* sizeof(unsigned short));
outbuf_addv(&out, "compiler function table %d (%d) \n",
ob->prog->num_functions_defined,
ob->prog->num_functions_defined * sizeof(function_t));
outbuf_addv(&out, "num strings %d\n", ob->prog->num_strings);
outbuf_addv(&out, "num vars %d (%d)\n", ob->prog->num_variables_defined,
ob->prog->num_variables_defined * (sizeof(char *) + sizeof(short)));
outbuf_addv(&out, "num inherits %d (%d)\n", ob->prog->num_inherited,
ob->prog->num_inherited * sizeof(inherit_t));
outbuf_addv(&out, "total size %d\n", ob->prog->total_size);
break;
case 2:
{
int i;
ob = arg[1].u.ob;
for (i=0; i<ob->prog->num_variables_total; i++) {
/* inefficient, but: */
outbuf_addv(&out, "%s: ", variable_name(ob->prog, i));
svalue_to_string(&ob->variables[i], &out, 2, 0, 0);
outbuf_add(&out, "\n");
}
break;
}
default:
bad_arg(1, F_DEBUG_INFO);
}
pop_stack();
pop_stack();
outbuf_push(&out);
}
boost::optional< substitution > backward_chaining( const atomic_sentence & sen )
{
for ( const atomic_sentence & se : known_facts )
{
auto ret = unify( se, sen );
if ( ret ) { return ret; }
}
if ( known_facts.empty( ) ) { return boost::optional< substitution >( ); }
std::set< std::string > var_name = variable_name( );
std::map< atomic_sentence, std::vector< std::vector< atomic_sentence > > > requiring_fact;
bool progress = true;
auto try_add =
[&]( const atomic_sentence & s )
{
if ( requiring_fact.count( s ) == 0 )
{
std::vector< std::vector< atomic_sentence > > deduct_from;
for ( const definite_clause & dc : kb )
{
assert( ! dc.premise.empty( ) );
substitution rename =
rename_variable(
dc.premise.begin( ),
dc.premise.end( ),
[&]( const std::string & v ){ return var_name.count( v ) == 0; },
[]( const std::string & n ){ return n + "_"; } );
auto ret = unify( rename( dc.conclusion ), s );
if ( ret )
{
std::vector< atomic_sentence > tem;
for ( const atomic_sentence & se : dc.premise )
{ tem.push_back( ( *ret )( rename( se ) ) ); }
deduct_from.push_back( tem );
}
}
requiring_fact.insert( std::make_pair( s, deduct_from ) );
progress = true;
}
};
try_add( sen );
while ( progress )
{
progress = false;
auto ret = unify( known_facts.back( ), sen );
if ( ret ) { return ret; }
std::vector< atomic_sentence > add;
for ( const std::pair< atomic_sentence, std::vector< std::vector< atomic_sentence > > > & p :
requiring_fact )
{
for ( const std::vector< atomic_sentence > & vec : p.second )
{
substitution rename =
rename_variable(
vec.begin( ),
vec.end( ),
[&]( const std::string & v ){ return var_name.count( v ) == 0; },
[]( const std::string & n ){ return n + "_"; } );
progress = try_infer_forward( vec, p.first, rename, sen ) || progress;
auto ret = unify( known_facts.back( ), sen );
if ( ret ) { return ret; }
std::copy( vec.begin( ), vec.end( ), std::back_inserter( add ) );
}
}
std::for_each( add.begin( ), add.end( ), try_add );
}
return boost::optional< substitution >( );
}
static bool
value_to_expr(globus_rsl_value_t * value, classad::ExprTree*& expr)
{
if (globus_rsl_value_is_literal(value))
{
char * literal = globus_rsl_value_literal_get_string(value);
if (!literal) { return false; }
classad::Value val;
try
{
val.SetIntegerValue(boost::lexical_cast<long long>(literal));
}
catch (const boost::bad_lexical_cast &)
{
try
{
val.SetRealValue(boost::lexical_cast<double>(literal));
}
catch (const boost::bad_lexical_cast &)
{
std::string lower = literal;
boost::algorithm::to_lower(lower);
if (lower == "true") { val.SetBooleanValue(true); }
else if (lower == "false") { val.SetBooleanValue(false); }
else { val.SetStringValue(literal); }
}
}
expr = classad::Literal::MakeLiteral(val);
if (!expr) { return false; }
return true;
}
else if (globus_rsl_value_is_sequence(value))
{
globus_list_t * value_list = globus_rsl_value_sequence_get_value_list(value);
if (!value_list) { return false; }
classad::ExprList expr_list;
while (!globus_list_empty(value_list))
{
globus_rsl_value_t *list_item = static_cast<globus_rsl_value_t*>(globus_list_first(value_list));
value_list = globus_list_rest(value_list);
if (!list_item) { continue; }
classad::ExprTree *expr_item = NULL;
if (!value_to_expr(list_item, expr_item) || !expr_item) { continue; }
expr_list.push_back(expr_item);
}
expr = expr_list.Copy();
return expr ? true : false;
}
else if (globus_rsl_value_is_concatenation(value))
{
globus_rsl_value_t *left_value = globus_rsl_value_concatenation_get_left(value);
globus_rsl_value_t *right_value = globus_rsl_value_concatenation_get_right(value);
if (!left_value || !right_value) { return false; }
classad::ExprTree *left_expr = NULL, *right_expr = NULL;
if (!value_to_expr(left_value, left_expr) || !left_expr || !value_to_expr(right_value, right_expr) || !right_expr) { return false; }
std::vector<classad::ExprTree*> argList; argList.push_back(left_expr); argList.push_back(right_expr);
expr = classad::FunctionCall::MakeFunctionCall("strcat", argList);
return expr ? true : false;
}
else if (globus_rsl_value_is_variable(value))
{
char * char_variable_name = globus_rsl_value_variable_get_name(value);
char * default_value = globus_rsl_value_variable_get_default(value);
if (!char_variable_name) { return false; }
// Canonical forms of Globus RSL strip out all underscores and makes the string
// lowercase. As ClassAds are case-preserving (and underscores are significant),
// we just do the former transform.
std::string variable_name(char_variable_name);
boost::algorithm::replace_all(variable_name, "_", "");
if (default_value)
{
// ifThenElse(isUndefined(variable_name), default_value, variable_name)
std::vector<classad::ExprTree*> ifArgList;
classad::ExprTree *attr1 = classad::AttributeReference::MakeAttributeReference(NULL, variable_name);
if (!attr1) { return false; }
std::vector<classad::ExprTree*> argList; argList.push_back(attr1);
classad::ExprTree *isUndefined = classad::FunctionCall::MakeFunctionCall("isUndefined", argList);
ifArgList.push_back(isUndefined);
classad::Value val; val.SetStringValue(default_value);
classad::ExprTree *lit = classad::Literal::MakeLiteral(val);
if (!lit) { return false; }
ifArgList.push_back(lit);
classad::ExprTree *attr2 = classad::AttributeReference::MakeAttributeReference(NULL, variable_name);
if (!attr2) { return false; }
ifArgList.push_back(attr2);
expr = classad::FunctionCall::MakeFunctionCall("ifThenElse", ifArgList);
}
else
{
expr = classad::AttributeReference::MakeAttributeReference(NULL, variable_name);
}
return expr ? true : false;
}
return false;
}
