void InfiniteDimensionalMCMCSampler::_write_state() { this->_append_scalar_dataset(this->_acc_dset, this->acc_prob()); this->_append_scalar_dataset(this->_avg_acc_dset, this->avg_acc_prob()); this->_append_scalar_dataset(this->_neg_log_llhd_dset, this->_llhd_val); this->_append_scalar_dataset(this->_L2_norm_samples_dset, this->current_physical_state->L2_norm()); this->_append_scalar_dataset(this->_L2_norm_mean_dset, this->current_physical_mean->L2_norm()); this->_append_scalar_dataset(this->_L2_norm_var_dset, this->current_physical_var->L2_norm()); // Now to write the fields. It appears to be a pain in the arse to write a // method to spit this out to HDF5 format. Also, this won't scale to // non-uniform finite element meshes. Therefore, I'm going to spit out an // ExodusII file for each sample, average and variance. Got disk space? std::stringstream basename; basename << this->m_ov->m_dataOutputDirName; basename << (this->m_env).subIdString(); basename << "/"; // Sigh std::ostringstream curr_iter; curr_iter << this->iteration(); std::string sample_name(basename.str() + "sample.e-s."); sample_name += curr_iter.str(); this->current_physical_state->save_function(sample_name, this->iteration()); std::string mean_name(basename.str() + "mean.e-s."); mean_name += curr_iter.str(); this->current_physical_mean->save_function(mean_name, this->iteration()); std::string var_name(basename.str() + "var.e-s."); var_name += curr_iter.str(); this->current_physical_var->save_function(var_name, this->iteration()); }
// This is where most of the strict/lazy distinction is. static value_t *e_fncall(env_t *env, expr_t *expr) { eli_closure_t c; binding_t *fn; // Call-by-value (strict function calls): evaluate each argument to // a value in the given environment. c.env = env; c.list = list_empty(); list_iterate(fncall_args(expr), e_expr_list_i, &c); list_reverse(c.list); switch (fncall_fn(expr)->type) { case p_var: // The function is literally the name of a function, and is // defined in the global environment. fn = (binding_t *)env_lookup(global_env, var_name(fncall_fn(expr))); assert(fn != NULL); // We must have exactly as many arguments as parameters. assert(list_length(c.list) == list_length(fn->params)); // Bind the function's parameters to the given arguments in a new // scope derived from the global scope. env = global_env; env_new_scope(&env); list_zip_with(fn->params, c.list, e_bind_params_i, env); // Evaluate the function's body in the new environment. return e_expr(env, fn->body); case p_datacons: { value_t *result; result = alloc_value(v_datacons); datacons_tag(result) = datacons_tag(fncall_fn(expr)); datacons_params(result) = c.list; // FIXME we'd like to assert that we got the right number of // arguments, but we don't know how many the data constructor // wanted. return result; } default: fprintf(stdout, "e_fncall: expression:\n"); pp_expr(stdout, fncall_fn(expr), 2); fprintf(stdout, "\non line %d is not a function-variable or a data constructor.\n", fn->line_num); error(""); return NULL; } }
void ada_read_sys(PolySys& sys) { int fail; std::cout << "testing reading and writing a system" << std::endl; //fail = syscon_read_system(); std::cout << "the system is .." << std::endl; fail = syscon_write_system(); // Get variable names int s_dim = 80; char *s = (char*) calloc(80,sizeof(char)); fail = syscon_string_of_symbols(&s_dim, s); string* x_names; var_name(s, s_dim, x_names); int dim = 4; int i = 1; double c[2]; int d[dim]; int n_eq = 0; fail = syscon_number_of_polynomials(&n_eq); sys.n_eq = n_eq; sys.dim = dim; sys.eq_space = new PolyEq[n_eq]; sys.pos_var = x_names; PolyEq* tmp_eq = sys.eq_space; for(int i=1; i<n_eq+1; i++){ int nt; fail = syscon_number_of_terms(i,&nt); //std::cout << " #terms in polynomial " << i << " : " << nt << std::endl; tmp_eq->n_mon = nt; tmp_eq->dim = dim; for(int j=1; j<=nt; j++) { fail = syscon_retrieve_term(i,j,dim,d,c); //std::cout << c[0] << " " << c[1] << std::endl; //for (int k=0; k<n; k++) std::cout << " " << d[k]; //std::cout << std::endl; bool constant_term = true; for (int k=0; k<dim; k++){ if(d[k]!=0){ constant_term = false; } } if(constant_term==true){ tmp_eq->n_mon--; tmp_eq->constant += CT(c[0],c[1]); //std::cout << "constant " << c[0] \ << " " << c[1] << std::endl; } else{
/** * Generate code to validate the specified variable declaration * using the specified indentation level and stream. * Checks any defined bounds or constraints on specialized types. * NOTE: bounded / specialized types are mutually exclusive * * @param[in] decl variable declaration * @param[in] indent indentation level * @param[in,out] o stream for generating */ void generate_validate_var_decl(const block_var_decl decl, int indent, std::ostream& o) { std::string var_name(decl.name()); std::vector<expression> ar_lens(decl.type().array_lens()); block_var_type btype = decl.type().innermost_type(); if (btype.has_def_bounds()) { range bounds = btype.bounds(); write_begin_array_dims_loop(decl, true, indent, o); if (bounds.has_low()) { generate_indent(indent + ar_lens.size(), o); o << "check_greater_or_equal(function__, "; o << "\"" << var_name; write_var_idx_array_dims(ar_lens.size(), o); o << "\", " << var_name; write_var_idx_array_dims(ar_lens.size(), o); o << ", "; generate_expression(bounds.low_.expr_, NOT_USER_FACING, o); o << ");" << EOL; } if (bounds.has_high()) { generate_indent(indent + ar_lens.size(), o); o << "check_less_or_equal(function__, "; o << "\"" << var_name; write_var_idx_array_dims(ar_lens.size(), o); o << "\", " << var_name; write_var_idx_array_dims(ar_lens.size(), o); o << ", "; generate_expression(bounds.high_.expr_, NOT_USER_FACING, o); o << ");" << EOL; } write_end_loop(ar_lens.size(), indent, o); } else if (btype.is_specialized()) { write_begin_array_dims_loop(decl, true, indent, o); generate_indent(indent + ar_lens.size(), o); o << "stan::math::check_"; // kludge - inconsistent naming specialized cholesky_factor types if (btype.name() == "cholesky_factor_cov") o << "cholesky_factor"; else o << btype.name(); o << "(function__, \"" << var_name; write_var_idx_array_dims(ar_lens.size(), o); o << "\", " << var_name; write_var_idx_array_dims(ar_lens.size(), o); o << ");" << EOL; write_end_loop(ar_lens.size(), indent, o); } }
/** * Generate code to to the specified stream to instantiate * a member variable declared in data block by calling the appropriate constructor. * Doesn't check variable dimensions - should have already been done * as part of checks on var_context. * * @param[in] var_decl block variable declaration * @param[in] indent indentation level * @param[in,out] o stream for generating */ void generate_data_var_ctor(const block_var_decl& var_decl, int indent, std::ostream& o) { std::string var_name(var_decl.name()); block_var_type btype = var_decl.type().innermost_type(); generate_indent(indent, o); o << var_name << " = "; if (var_decl.bare_type().is_int_type()) { o << "int(0)"; } else if (var_decl.bare_type().is_double_type()) { o << "double(0)"; } else { generate_var_constructor(var_decl, "double", o); } o << ";" << EOL; }
static int do_printenv(struct command *cmdtp, int argc, char *argv[]) { struct variable_d *var; struct env_context *c, *current_c; if (argc == 2) { const char *val = getenv(argv[1]); if (val) { printf("%s=%s\n", argv[1], val); return 0; } printf("## Error: \"%s\" not defined\n", argv[1]); return 1; } current_c = get_current_context(); var = current_c->local->next; printf("locals:\n"); while (var) { printf("%s=%s\n", var_name(var), var_val(var)); var = var->next; } printf("globals:\n"); c = get_current_context(); while(c) { var = c->global->next; while (var) { printf("%s=%s\n", var_name(var), var_val(var)); var = var->next; } c = c->parent; } return 0; }
bool MsdpNetwork::process_var(cursor& c) { const tbyte* p = c.p; if (p == c.e || *p != MSDP_VAR) return false; const tbyte* b = p+1; while (b != c.e && *b != MSDP_VAL) { if (*b < ' ') return false; b++; } if (b == c.e) return false; std::string var_name((const char*)(p+1), b-p-1); lua_pushstring(L, var_name.c_str()); c.p = b; return true; }
void add_row(GtkToolButton* toolbutton, gpointer user_data) { /* Context data */ GtkListStore* restrictions = GTK_LIST_STORE(gtk_tree_view_get_model(restrictions_view)); int vars = gtk_spin_button_get_value_as_int(variables); GValue initi = G_VALUE_INIT; g_value_init(&initi, G_TYPE_INT); GValue inits = G_VALUE_INIT; g_value_init(&inits, G_TYPE_STRING); GtkTreeIter iter; gtk_list_store_append(restrictions, &iter); int size = vars + 2; for(int i = 0; i < vars; i++) { g_value_set_int(&initi, 1); gtk_list_store_set_value(restrictions, &iter, i, &initi); char* text = var_name(1, i, false); g_value_set_string(&inits, text); gtk_list_store_set_value(restrictions, &iter, size + i, &inits); free(text); g_value_set_string(&inits, PLUS); gtk_list_store_set_value(restrictions, &iter, 2 * size + i, &inits); } /* Set type */ g_value_set_int(&initi, GE); gtk_list_store_set_value(restrictions, &iter, size - 2, &initi); g_value_set_string(&inits, GES); gtk_list_store_set_value(restrictions, &iter, 2 * size - 2, &inits); g_value_set_string(&inits, ""); gtk_list_store_set_value(restrictions, &iter, 3 * size - 2, &inits); /* Set equality */ g_value_set_int(&initi, 0); gtk_list_store_set_value(restrictions, &iter, size - 1, &initi); char* text = num_name(0, false); g_value_set_string(&inits, text); gtk_list_store_set_value(restrictions, &iter, 2 * size - 1, &inits); free(text); g_value_set_string(&inits, ""); gtk_list_store_set_value(restrictions, &iter, 3 * size - 1, &inits); /* Select new row */ GtkTreePath* model_path = gtk_tree_model_get_path( GTK_TREE_MODEL(restrictions), &iter); gtk_tree_view_set_cursor(restrictions_view, model_path, gtk_tree_view_get_column(restrictions_view, 0), true); gtk_tree_path_free(model_path); return; }
bool change_function(int vars) { /* Clear model */ clear_liststore(function_view); /* Create the dynamic types array */ GType* types = (GType*) malloc(3 * vars * sizeof(GType)); if(types == NULL) { return false; } /* Set type in the dynamic types array */ for(int i = 0; i < vars; i++) { types[i] = G_TYPE_INT; /* Coeffs */ types[vars + i] = G_TYPE_STRING; /* Text */ types[2 * vars + i] = G_TYPE_STRING; /* Signs */ } /* Create and fill the new model */ GtkListStore* function = gtk_list_store_newv(3 * vars, types); GtkTreeIter iter; GValue initi = G_VALUE_INIT; g_value_init(&initi, G_TYPE_INT); GValue inits = G_VALUE_INIT; g_value_init(&inits, G_TYPE_STRING); gtk_list_store_append(function, &iter); for(int i = 0; i < vars; i++) { g_value_set_int(&initi, 1); gtk_list_store_set_value(function, &iter, i, &initi); char* text = var_name(1, i, false); g_value_set_string(&inits, text); gtk_list_store_set_value(function, &iter, vars + i, &inits); free(text); g_value_set_string(&inits, PLUS); gtk_list_store_set_value(function, &iter, 2 * vars + i, &inits); } /* Clear the previous columns */ for(int i = gtk_tree_view_get_n_columns(function_view) - 1; i >= 0; i--) { gtk_tree_view_remove_column( function_view, gtk_tree_view_get_column(function_view, i) ); } /* Create the new columns */ for(int i = 0; i < vars; i++) { /* Create sign column */ if(i > 0) { GtkCellRenderer* sign = gtk_cell_renderer_text_new(); GtkTreeViewColumn* sign_c = gtk_tree_view_column_new_with_attributes( "", sign, /* Title, renderer */ "markup", 2 * vars + i, NULL); gtk_tree_view_append_column(function_view, sign_c); } /* Create text column */ /* Create and configure cell */ GtkCellRenderer* cell = gtk_cell_renderer_spin_new(); gtk_cell_renderer_set_alignment(cell, 1.0, 0.5); g_object_set(cell, "editable", true, NULL); /* Configure callbacks */ g_signal_connect(G_OBJECT(cell), "editing-started", G_CALLBACK(function_edit_started_cb), GINT_TO_POINTER(i)); function_edit_started_cb(cell, NULL, NULL, GINT_TO_POINTER(i)); g_signal_connect(G_OBJECT(cell), "edited", G_CALLBACK(function_edited_cb), GINT_TO_POINTER(i)); /* Configure column */ GtkTreeViewColumn* column = gtk_tree_view_column_new_with_attributes( "", cell, /* Title, renderer */ "markup", vars + i, NULL); gtk_tree_view_column_set_min_width(column, 100); gtk_tree_view_append_column(function_view, column); } gtk_tree_view_append_column(function_view, gtk_tree_view_column_new()); /* Set the new model */ gtk_tree_view_set_model(function_view, GTK_TREE_MODEL(function)); /* Free resources */ g_object_unref(G_OBJECT(function)); free(types); return true; }
void writeback(GtkTreeModel* model, gchar* path, int vars, bool is_var, gchar* new_text, gpointer user_data) { int column = GPOINTER_TO_INT(user_data); DEBUG("%s at (%i, %i)\n", new_text, atoi(path), column); /* Get the coefficient */ int coeff = 0; if(!is_empty_string(new_text)) { char* end; coeff = (int) strtol(new_text, &end, 10); if(*end != '\0') { /* Conversion wasn't successful */ DEBUG("Unable to parse %s\n", new_text); return; } } /* Get reference to model */ GtkTreeIter iter; gtk_tree_model_get_iter_from_string(model, &iter, path); /* Set the model */ GValue gvali = G_VALUE_INIT; g_value_init(&gvali, G_TYPE_INT); GValue gvals = G_VALUE_INIT; g_value_init(&gvals, G_TYPE_STRING); /* Coeff */ g_value_set_int(&gvali, coeff); gtk_list_store_set_value( GTK_LIST_STORE(model), &iter, column, &gvali); g_value_unset(&gvali); /* Text */ g_value_set_string(&gvals, ""); if(!is_var) { char* text = num_name(coeff, true); g_value_set_string(&gvals, text); free(text); } else if(coeff != 0) { char* text = var_name(coeff, column, column == 0); g_value_set_string(&gvals, text); free(text); } gtk_list_store_set_value( GTK_LIST_STORE(model), &iter, vars + column, &gvals); /* Sign */ g_value_set_string(&gvals, ""); if(is_var) { if((column != 0) && (coeff != 0)) { if(coeff > 0) { g_value_set_string(&gvals, PLUS); } else { g_value_set_string(&gvals, MINUS); } } } gtk_list_store_set_value( GTK_LIST_STORE(model), &iter, 2 * vars + column, &gvals); g_value_unset(&gvals); }
void option_db_t::parse_token( const std::string& token ) { if ( token == "-" ) { parse_file( stdin ); return; } std::string::size_type cut_pt = token.find( '=' ); if ( cut_pt == token.npos ) { io::cfile file = open_file( auto_path, token ); if ( ! file ) { std::stringstream s; s << "Unexpected parameter '" << token << "'. Expected format: name=value"; throw std::invalid_argument( s.str() ); } parse_file( file ); return; } std::string name( token, 0, cut_pt ), value( token, cut_pt + 1, token.npos ); std::string::size_type start = 0; while ( ( start = value.find( "$(", start ) ) != std::string::npos ) { std::string::size_type end = value.find( ')', start ); if ( end == std::string::npos ) { std::stringstream s; s << "Variable syntax error: '" << token << "'"; throw std::invalid_argument( s.str() ); } value.replace( start, ( end - start ) + 1, var_map[ value.substr( start + 2, ( end - start ) - 2 ) ] ); } if ( name.size() >= 1 && name[ 0 ] == '$' ) { if ( name.size() < 3 || name[ 1 ] != '(' || name[ name.size() - 1 ] != ')' ) { std::stringstream s; s << "Variable syntax error: '" << token << "'"; throw std::invalid_argument( s.str() ); } std::string var_name( name, 2, name.size() - 3 ); var_map[ var_name ] = value; } else if ( name == "input" ) { io::cfile file( open_file( auto_path, value ) ); if ( ! file ) { std::stringstream s; s << "Unable to open input parameter file '" << value << "'"; throw std::invalid_argument( s.str() ); } parse_file( file ); } else { add( "global", name, value ); } }
static value_t *e_expr(env_t *env, expr_t *expr) { value_t *result; switch (expr->type) { default: // This is to handle invalid tags. case p_unused: if (*(int *)NULL) { printf("should crash.\n"); } return NULL; case p_and: { value_t *l = e_expr(env, binary_left(expr)); if (bool_val(l)) { result = e_expr(env, binary_right(expr)); } else { result = l; } } break; case p_or: { value_t *l = e_expr(env, binary_left(expr)); if (bool_val(l)) { result = l; } else { result = e_expr(env, binary_right(expr)); } } break; case p_add: case p_div: case p_ge: case p_gt: case p_le: case p_lt: case p_mod: case p_mul: case p_sub: result = e_binary_op(env, expr); break; case p_bconst: result = alloc_value(v_bool); bool_val(result) = bool_val(expr); break; case p_cconst: result = alloc_value(v_char); char_val(result) = char_val(expr); break; case p_datacons: result = e_datacons(env, expr); break; case p_eqop: result = e_equals(env, binary_left(expr), binary_right(expr)); break; case p_fncall: result = e_fncall(env, fncall_fn(expr), fncall_args(expr)); break; case p_nconst: result = alloc_value(v_num); num_val(result) = num_val(expr); break; case p_ite: result = e_ite(env, expr); break; case p_let: result = e_let(env, expr); break; case p_listcons: result = e_listcons(env, expr); break; case p_listlit: result = e_listlit(env, expr); break; case p_listempty: result = e_listempty(); break; case p_match: result = e_match(env, expr); break; case p_ne: result = e_equals(env, binary_left(expr), binary_right(expr)); bool_val(result) = !bool_val(result); break; case p_negate: result = e_expr(env, unary_expr(expr)); bool_val(result) = !bool_val(result); break; case p_tuple: result = e_tuple(env, expr); break; case p_var: result = env_lookup(env, var_name(expr)); if (result == NULL) { error("e_expr: variable '%s' not in scope on line %d.\n", var_name(expr), expr->line_num); } result = thunk_force(result); break; } return result; }
// Mapped over the clauses in a "match" expression. static int e_match_pat_i(void *data, void *info) { pm_closure_t *pmc = (pm_closure_t *)info; clause_t *c = (clause_t *)data; // The style of pattern matching depends on the type of the pattern: // - constants match literally // - variables match anything (and extend the environment) // - tuples always match (and extend the environment) // - data constructors are more complex. /// switch (c->pattern->type) { // Constants: match literally, no binding. case p_bconst: if (bool_val(c->pattern) == bool_val(pmc->val)) { pmc->match_body = c->body; } break; case p_cconst: if (char_val(c->pattern) == char_val(pmc->val)) { pmc->match_body = c->body; } break; case p_nconst: if (num_val(c->pattern) == num_val(pmc->val)) { pmc->match_body = c->body; } break; case p_listempty: if (pmc->val->type == v_datacons && strcmp(datacons_tag(pmc->val), listEmptyTag) == 0) { pmc->match_body = c->body; } break; case p_var: // Matches anything. Bind it. env_add_binding(pmc->env, var_name(c->pattern), pmc->val); pmc->match_body = c->body; break; case p_listcons: // Check the list contains at least one element, then bind variables. if (pmc->val->type == v_datacons && strcmp(datacons_tag(pmc->val), listConsTag) == 0) { value_t *head; value_t *tail; head = list_nth(datacons_params(pmc->val), 0); tail = list_nth(datacons_params(pmc->val), 1); env_add_binding(pmc->env, listcons_hvar(c->pattern), head); env_add_binding(pmc->env, listcons_tvar(c->pattern), tail); pmc->match_body = c->body; } break; case p_datacons: // Check the tag matches, then bind the arguments (if any). if (strcmp(datacons_tag(c->pattern), datacons_tag(pmc->val)) == 0) { list_zip_with(datacons_params(c->pattern), datacons_params(pmc->val), e_bind_params_i, pmc->env); pmc->match_body = c->body; } break; case p_tuple: // Always matches (assuming the program type checks). Bind the variables. list_zip_with(tuple_val(c->pattern), tuple_val(pmc->val), e_bind_params_i, pmc->env); pmc->match_body = c->body; break; default: error("INTERNAL pattern match: invalid pattern.\n"); } return pmc->match_body == NULL; }
int fs_optimise_triple_pattern(fs_query_state *qs, fs_query *q, int block, rasqal_triple *patt[], int length, int start) { if (length - start < 2 || q->opt_level < 1) { return 1; } rasqal_triple **pbuf = malloc(length * sizeof(rasqal_triple *)); memcpy(pbuf, patt, sizeof(rasqal_triple *) * length); memset(patt, 0, length * sizeof(rasqal_triple *)); int append_pos = start; for (int i=0; i<start; i++) { pbuf[i] = patt[i]; } /* roughly sort into order: * const subject and predicate * const predicate and object * const subject * const object * const graph * const predicate * all variable */ #if 0 /* this code complicates things greatly, so I've removed it for now - swh should maybe be reexamined if/when we get histograms back */ for (int i=start; i<length; i++) { if (!pbuf[i]) { continue; } if (fs_bind_freq(qs, q, block, pbuf[i]) == 1) { patt[append_pos++] = pbuf[i]; pbuf[i] = NULL; } } #endif for (int i=start; i<length; i++) { if (!pbuf[i]) { continue; } if (fs_opt_is_const(q->bb[block], pbuf[i]->subject) && fs_opt_is_const(q->bb[block], pbuf[i]->predicate) && fs_opt_is_bound(q->bb[block], pbuf[i]->object)) { patt[append_pos++] = pbuf[i]; pbuf[i] = NULL; } } /* triples like :s :p ?o, where :p != rdf:type */ for (int i=0; i<length; i++) { if (!pbuf[i]) { continue; } if (fs_opt_is_const(q->bb[block], pbuf[i]->subject) && fs_opt_is_const(q->bb[block], pbuf[i]->predicate) && fs_opt_is_bound(q->bb[block], pbuf[i]->object) && !fs_opt_literal_is_rdf_type(pbuf[i]->predicate)) { patt[append_pos++] = pbuf[i]; pbuf[i] = NULL; } } /* triples like :s :p _, where :p != rdf:type */ for (int i=0; i<length; i++) { if (!pbuf[i]) { continue; } if (fs_opt_is_const(q->bb[block], pbuf[i]->subject) && fs_opt_is_const(q->bb[block], pbuf[i]->predicate) && !fs_opt_literal_is_rdf_type(pbuf[i]->predicate)) { patt[append_pos++] = pbuf[i]; pbuf[i] = NULL; } } /* triples like ?s :p :o, where :p != rdf:type */ for (int i=0; i<length; i++) { if (!pbuf[i]) { continue; } if (fs_opt_is_bound(q->bb[block], pbuf[i]->subject) && fs_opt_is_const(q->bb[block], pbuf[i]->predicate) && fs_opt_is_const(q->bb[block], pbuf[i]->object) && !fs_opt_literal_is_rdf_type(pbuf[i]->predicate)) { patt[append_pos++] = pbuf[i]; pbuf[i] = NULL; } } /* triples like ?s rdf:type :o */ for (int i=0; i<length; i++) { if (!pbuf[i]) { continue; } if (fs_opt_is_bound(q->bb[block], pbuf[i]->subject) && fs_opt_is_const(q->bb[block], pbuf[i]->predicate) && fs_opt_is_const(q->bb[block], pbuf[i]->object)) { patt[append_pos++] = pbuf[i]; pbuf[i] = NULL; } } for (int i=0; i<length; i++) { if (!pbuf[i]) { continue; } if (fs_opt_is_const(q->bb[block], pbuf[i]->subject) && fs_opt_is_bound(q->bb[block], pbuf[i]->object)) { patt[append_pos++] = pbuf[i]; pbuf[i] = NULL; } } for (int i=0; i<length; i++) { if (!pbuf[i]) { continue; } if (fs_opt_is_const(q->bb[block], pbuf[i]->object) && fs_opt_is_bound(q->bb[block], pbuf[i]->subject)) { patt[append_pos++] = pbuf[i]; pbuf[i] = NULL; } } for (int i=0; i<length; i++) { if (!pbuf[i]) { continue; } if (fs_opt_is_const(q->bb[block], pbuf[i]->predicate) && (fs_opt_is_bound(q->bb[block], pbuf[i]->subject) || fs_opt_is_bound(q->bb[block], pbuf[i]->object))) { patt[append_pos++] = pbuf[i]; pbuf[i] = NULL; } } for (int i=0; i<length; i++) { if (!pbuf[i]) { continue; } if (fs_opt_is_const(q->bb[block], pbuf[i]->origin)) { patt[append_pos++] = pbuf[i]; pbuf[i] = NULL; } } for (int i=0; i<length; i++) { if (!pbuf[i]) { continue; } patt[append_pos++] = pbuf[i]; pbuf[i] = NULL; } free(pbuf); if (append_pos != length) { fs_error(LOG_CRIT, "Optimser mismatch error"); } #ifdef DEBUG_OPTIMISER printf("optimiser choices look like:\n"); for (int i=start; i<length; i++) { printf("%4d: ", i); rasqal_triple_print(patt[i], stdout); printf("\n"); } #endif /* If the next two or more pattern's subjects are both variables, we might be able * to multi reverse bind them */ if (var_name(patt[start]->subject) && var_name(patt[start+1]->subject) && !var_name(patt[start]->predicate) && !var_name(patt[start]->object) && fs_opt_num_vals(q->bb[block], patt[start]->predicate) == 1 && fs_opt_num_vals(q->bb[block], patt[start]->origin) == 0 && fs_opt_num_vals(q->bb[block], patt[start+1]->origin) == 0) { char *svname = var_name(patt[start]->subject); int count = 1; while (start+count < length && !fs_opt_is_const(q->bb[block], patt[start+count]->subject) && !strcmp(svname, var_name(patt[start+count]->subject)) && !var_name(patt[start+count]->object) && !var_name(patt[start+count]->predicate)) { count++; } /* if we found a reverse bind pair then we may as well use that, rather * than pressing on and using the freq data to pick an order, the * backend has more complete information */ if (count > 1) return count; } if (length - start > 1) { int freq_a = fs_bind_freq(qs, q, block, patt[start]); int freq_b = fs_bind_freq(qs, q, block, patt[start+1]); /* the 2nd is cheaper than the 1st, then swap them */ if (freq_b < freq_a) { rasqal_triple *tmp = patt[start]; patt[start] = patt[start+1]; patt[start+1] = tmp; } } return 1; }
void ada_read_sys ( int verbose, PolySys& sys ) { int fail,nbsym; fail = syscon_number_of_symbols(&nbsym); if(verbose > 0) { std::cout << "the system is .." << std::endl; fail = syscon_write_dobldobl_system(); std::cout << "the number of symbols : " << nbsym << std::endl; } int s_dim = 80*nbsym; char *s = (char*) calloc(s_dim,sizeof(char)); fail = syscon_string_of_symbols(&s_dim, s); string* x_names; int dim = 0; var_name(s, s_dim, x_names, dim); int i = 1; if(verbose > 0) std::cout << "dim = " << dim << std::endl; double c[4]; /* two consecutive double doubles are real and imag parts */ int d[dim]; int n_eq = 0; fail = syscon_number_of_dobldobl_polynomials(&n_eq); sys.n_eq = n_eq; sys.dim = dim; sys.eq_space = new PolyEq[n_eq]; sys.pos_var = x_names; PolyEq* tmp_eq = sys.eq_space; for(int i=1; i<n_eq+1; i++) { int nt; fail = syscon_number_of_dobldobl_terms(i,&nt); if(verbose > 0) std::cout << " #terms in polynomial " << i << " : " << nt << std::endl; tmp_eq->n_mon = nt; tmp_eq->dim = dim; for(int j=1; j<=nt; j++) { fail = syscon_retrieve_dobldobl_term(i,j,dim,d,c); if(verbose > 0) { std::cout << c[0] << " " << c[2] << std::endl; for (int k=0; k<dim; k++) std::cout << " " << d[k]; std::cout << std::endl; } bool constant_term = true; for(int k=0; k<dim; k++) if(d[k]!=0) constant_term = false; if(constant_term==true) { tmp_eq->n_mon--; tmp_eq->constant += CT(c[0],c[2]); } else { T1 cffs[2]; T1 realpcff; T1 imagpcff; realpcff.x[0] = c[0]; realpcff.x[1] = c[1]; imagpcff.x[0] = c[2]; imagpcff.x[1] = c[3]; cffs[0] = realpcff; cffs[1] = imagpcff; PolyMon* a = new PolyMon(dim,d,cffs); tmp_eq->mon.push_back(a); } } if(verbose > 0) tmp_eq->print(x_names); sys.eq.push_back(tmp_eq); tmp_eq++; } if(verbose > 0) { sys.print(); std::cout << "End" << std::endl; } }