/** \brief in the setup of this object, make a new system randomizer. \param solve_options the current state of the solver. \param W input witness set, witn numbers of linears, patches, and variables. */ void make_randomizer(const SolverConfiguration & solve_options, const WitnessSet & W) { randomizer_ = std::make_shared<SystemRandomizer>(*(new SystemRandomizer)); randomizer_->setup(W.num_variables()-W.num_linears()-W.num_patches(), solve_options.PPD.num_funcs); }
void create_sliced_system(boost::filesystem::path input_file, boost::filesystem::path output_file, vec_mp * linears, int num_to_add, const WitnessSet & W) { #ifdef functionentry_output std::cout << "create_sliced_system" << std::endl; #endif if (W.num_var_names()==0) { std::cout << "trying to create a sliced system, but witness set does not have the variable names." << std::endl; deliberate_segfault(); } int *declarations = NULL; partition_parse(&declarations, input_file, "func_input", "config", 0); // the 0 means not self conjugate. free(declarations); FILE *OUT = safe_fopen_write(output_file); FILE *IN = safe_fopen_read("func_input"); fprintf(OUT,"INPUT\n\n"); copyfile(IN,OUT); fclose(IN); std::vector< int > indicators; for (int ii=0; ii<num_to_add; ii++) { indicators.push_back(rand()); } for (int ii=0; ii<num_to_add; ii++) { std::stringstream linname; linname << "supp_lin_" << indicators[ii]; write_vector_as_constants(linears[ii], linname.str(), OUT); linname.clear(); linname.str(""); } for (int ii=0; ii<num_to_add; ii++) { fprintf(OUT,"function supp_lin_%d;\n",indicators[ii]); } for (int ii=0; ii<num_to_add; ii++) { fprintf(OUT,"supp_lin_%d = supp_lin_%d_1",indicators[ii],indicators[ii]); for (int jj=1; jj<W.num_variables(); jj++) { fprintf(OUT," + %s*supp_lin_%d_%d",W.name(jj).c_str(), indicators[ii],jj+1); } fprintf(OUT, ";\n\n"); } fprintf(OUT,"END;\n\n\n\n"); for (unsigned int ii=0; ii<W.num_patches(); ii++) { std::stringstream linname; linname << "patch_" << ii; write_vector_as_constants(W.patch(ii), linname.str(), OUT); linname.clear(); linname.str(""); } fclose(OUT); }
void WitnessSet::merge(const WitnessSet & W_in, tracker_config_t * T) { //error checking first if ( (num_vars_==0) && (W_in.num_vars_!=0) && (num_points()==0)) { num_vars_ = W_in.num_vars_; num_natty_vars_ = W_in.num_natty_vars_; } if (W_in.num_natty_vars_ != this->num_natty_vars_) { std::stringstream ss; ss << "merging two witness sets with differing numbers of natural variables. "<< W_in.num_natural_variables() <<" merging set, "<< this->num_natural_variables() << " existing\n", throw std::logic_error(ss.str()); } //just mindlessly add the linears. up to user to ensure linears get merged correctly. no way to know what they want... for (unsigned int ii = 0; ii<W_in.num_linears(); ii++) { WitnessSet::add_linear(W_in.linear(ii)); } for (unsigned int ii = 0; ii<W_in.num_points(); ii++) { int is_new = 1; vec_mp & in_point = W_in.point(ii); for (unsigned int jj = 0; jj<num_points(); jj++){ vec_mp & curr_point = this->point(jj); //cache the sizes int in_size = in_point->size; int curr_size = curr_point->size; in_point->size = this->num_natural_variables(); curr_point->size = this->num_natural_variables(); if (isSamePoint_homogeneous_input(curr_point, in_point, T->final_tol_times_mult)) { is_new = 0; in_point->size = in_size; curr_point->size = curr_size; break; } // restore the sizes in_point->size = in_size; curr_point->size = curr_size; } if (is_new==1) WitnessSet::add_point( (in_point) ); } for (unsigned int ii = 0; ii<W_in.num_patches(); ii++) { int is_new = 1; for (unsigned int jj = 0; jj<this->num_patches(); jj++){ if ( this->patch(jj)->size == W_in.patch(ii)->size) { if (isSamePoint_inhomogeneous_input(patch(jj), W_in.patch(ii), T->final_tol_times_mult)) { is_new = 0; break; } } } if (is_new==1) WitnessSet::add_patch(W_in.patch(ii)); } return; }//re: merge_witness_sets
void nullspace_config_setup_right(NullspaceConfiguration *ns_config, vec_mp *pi, // an array of projections, the number of which is the target dimensions int ambient_dim, int *max_degree, // a pointer to the value std::shared_ptr<SystemRandomizer> randomizer, const WitnessSet & W, SolverConfiguration & solve_options) { ns_config->set_side(nullspace_handedness::RIGHT); int toss; parse_input_file(W.input_filename(), &toss); // re-create the parsed files for the stuffs (namely the SLP). ns_config->set_randomizer(randomizer); // set the pointer. this randomizer is for the underlying system. *max_degree = randomizer->max_degree()-1; // minus one for differentiated degree ns_config->max_degree = *max_degree; // set some integers ns_config->num_projections = ambient_dim; ns_config->num_v_vars = W.num_natural_variables()-1; ns_config->num_synth_vars = W.num_synth_vars(); // this may get a little crazy if we chain into this more than once. this code is written to be called into only one time beyond the first. ns_config->num_natural_vars = W.num_natural_variables(); ns_config->ambient_dim = ambient_dim; ns_config->target_projection = (vec_mp *) br_malloc(ns_config->num_projections * sizeof(vec_mp)); for (int ii=0; ii<ns_config->num_projections; ii++) { init_vec_mp2(ns_config->target_projection[ii], W.num_variables(),solve_options.T.AMP_max_prec); ns_config->target_projection[ii]->size = W.num_variables(); vec_cp_mp(ns_config->target_projection[ii], pi[ii]); } ns_config->num_jac_equations = (ns_config->num_natural_vars - 1);// N-1; the subtraction of 1 is for the 1 hom-var. // me must omit any previously added synthetic vars. ns_config->num_additional_linears = ambient_dim-1; ns_config->num_v_linears = ns_config->num_jac_equations; // this check is correct. int check_num_func = randomizer->num_rand_funcs() + ns_config->num_jac_equations + ns_config->num_additional_linears + W.num_patches() + 1; // +1 for v patch from this incoming computation int check_num_vars = ns_config->num_natural_vars + ns_config->num_synth_vars + ns_config->num_v_vars; if (check_num_func != check_num_vars) { std::cout << color::red(); std::cout << "mismatch in number of equations...\n" << std::endl; std::cout << "left: " << check_num_func << " right " << check_num_vars << std::endl; std::cout << color::console_default(); throw std::logic_error("logic error in nullspace_left"); } // set up the linears in $v$ ( the M_i linears) ns_config->v_linears = (vec_mp *)br_malloc(ns_config->num_v_linears*sizeof(vec_mp)); for (int ii=0; ii<ns_config->num_v_linears; ii++) { init_vec_mp2(ns_config->v_linears[ii],ns_config->num_v_vars,solve_options.T.AMP_max_prec); ns_config->v_linears[ii]->size = ns_config->num_v_vars; for (int jj=0; jj<ns_config->num_v_vars; jj++){ get_comp_rand_mp(&ns_config->v_linears[ii]->coord[jj]); // should this be real? no. } } // the last of the linears will be used for the slicing, and passed on to later routines int offset = 1; ns_config->additional_linears_terminal = (vec_mp *)br_malloc((ns_config->num_additional_linears)*sizeof(vec_mp)); ns_config->additional_linears_starting = (vec_mp *)br_malloc((ns_config->num_additional_linears)*sizeof(vec_mp)); for (int ii=0; ii<ns_config->num_additional_linears; ii++) { init_vec_mp2(ns_config->additional_linears_terminal[ii],W.num_variables(),solve_options.T.AMP_max_prec); ns_config->additional_linears_terminal[ii]->size = W.num_variables(); for (int jj=0; jj<W.num_natural_variables(); jj++){ get_comp_rand_mp(&ns_config->additional_linears_terminal[ii]->coord[jj]); // should this be real? no. } for (int jj=W.num_natural_variables(); jj<W.num_variables(); jj++) { set_zero_mp(&ns_config->additional_linears_terminal[ii]->coord[jj]); } init_vec_mp2(ns_config->additional_linears_starting[ii],W.num_variables(),solve_options.T.AMP_max_prec); ns_config->additional_linears_starting[ii]->size = W.num_variables(); vec_cp_mp(ns_config->additional_linears_starting[ii], W.linear(ii+offset)); } // set up the patch in $v$. we will include this in an inversion matrix to get the starting $v$ values. init_vec_mp2(ns_config->v_patch,ns_config->num_v_vars,solve_options.T.AMP_max_prec); ns_config->v_patch->size = ns_config->num_v_vars; for (int ii=0; ii<ns_config->num_v_vars; ii++) { get_comp_rand_mp(&ns_config->v_patch->coord[ii]); } mat_mp temp_getter; init_mat_mp2(temp_getter,0, 0,solve_options.T.AMP_max_prec); temp_getter->rows = 0; temp_getter->cols = 0; //the 'ns_config->starting_linears' will be used for the x variables. we will homotope to these 1 at a time ns_config->starting_linears = (vec_mp **)br_malloc( randomizer->num_rand_funcs()*sizeof(vec_mp *)); for (int ii=0; ii<randomizer->num_rand_funcs(); ii++) { int curr_degree = std::max(0,randomizer->randomized_degree(ii)-1); ns_config->starting_linears[ii] = (vec_mp *) br_malloc(curr_degree*sizeof(vec_mp)); make_matrix_random_mp(temp_getter,curr_degree, W.num_natural_variables(), solve_options.T.AMP_max_prec); // this matrix is nearly orthogonal for (unsigned int jj=0; jj<curr_degree; jj++) { init_vec_mp2(ns_config->starting_linears[ii][jj],W.num_variables(),solve_options.T.AMP_max_prec); ns_config->starting_linears[ii][jj]->size = W.num_variables(); for (int kk=0; kk<W.num_natural_variables(); kk++) { set_mp(&ns_config->starting_linears[ii][jj]->coord[kk], &temp_getter->entry[jj][kk]); } for (int kk=W.num_natural_variables(); kk<W.num_variables(); kk++) { set_zero_mp(&ns_config->starting_linears[ii][jj]->coord[kk]); } } } clear_mat_mp(temp_getter); return; }