void clear()
{
if (num_additional_linears>0) {
for (int ii=0; ii<num_additional_linears; ii++) {
clear_vec_mp(additional_linears_terminal[ii]);
}
free(additional_linears_terminal);
for (int ii=0; ii<num_additional_linears; ii++) {
clear_vec_mp(additional_linears_starting[ii]);
}
free(additional_linears_starting);
}
if (num_jac_equations>0) {
if (side_ == nullspace_handedness::LEFT) {
for (int ii=0; ii<num_jac_equations; ii++) {
for (int jj=0; jj<max_degree; jj++) {
clear_vec_mp(starting_linears[ii][jj]);
}
free(starting_linears[ii]);
}
}
else
{
for (int ii=0; ii<randomizer()->num_rand_funcs(); ii++) {
for (int jj=0; jj<randomizer()->randomized_degree(ii)-1; jj++) {
clear_vec_mp(starting_linears[ii][jj]);
}
free(starting_linears[ii]);
}
}
free(starting_linears);
}
if (num_v_linears>0) {
for (int ii=0; ii<num_v_linears; ii++) {
clear_vec_mp(v_linears[ii]);
}
free(v_linears);
}
clear_vec_mp(v_patch);
clear_mat_mp(jac_with_proj);
if (num_projections>0) {
for (int ii=0; ii<num_projections; ii++) {
clear_vec_mp(target_projection[ii]);
}
free(target_projection);
}
if (this->MPType==2) {
if (num_additional_linears>0) {
for (int ii=0; ii<num_additional_linears; ii++) {
clear_vec_mp(additional_linears_terminal_full_prec[ii]);
}
free(additional_linears_terminal_full_prec);
for (int ii=0; ii<num_additional_linears; ii++) {
clear_vec_mp(additional_linears_starting_full_prec[ii]);
}
free(additional_linears_starting_full_prec);
}
if (num_jac_equations>0) {
if (side_ == nullspace_handedness::LEFT) {
for (int ii=0; ii<num_jac_equations; ii++) {
for (int jj=0; jj<max_degree; jj++) {
clear_vec_mp(starting_linears_full_prec[ii][jj]);
}
free(starting_linears_full_prec[ii]);
}
}
else
{
for (int ii=0; ii<randomizer()->num_rand_funcs(); ii++) {
for (int jj=0; jj<randomizer()->randomized_degree(ii)-1; jj++) {
clear_vec_mp(starting_linears_full_prec[ii][jj]);
}
free(starting_linears_full_prec[ii]);
}
}
free(starting_linears_full_prec);
}
for (int ii=0; ii<num_v_linears; ii++)
clear_vec_mp(v_linears_full_prec[ii]);
free(v_linears_full_prec);
clear_vec_mp(v_patch_full_prec);
clear_mat_mp(jac_with_proj_full_prec);
if (num_projections>0) {
for (int ii=0; ii<num_projections; ii++) {
clear_vec_mp(target_projection_full_prec[ii]);
}
free(target_projection_full_prec);
}
}
clear_deriv(SLP_derivative);
delete this->SLP_derivative;
} // re: clear
int compute_crit_nullspace_right(SolverOutput & solve_out, // the returned value
const WitnessSet & W,
std::shared_ptr<SystemRandomizer> randomizer,
vec_mp *pi, // an array of projections, the number of which is the target dimensions
int ambient_dim,
BertiniRealConfig & program_options,
SolverConfiguration & solve_options,
NullspaceConfiguration *ns_config)
{
//many of the 1's here should be replaced by the number of patch equations, or the number of variable_groups
// get the max degree of the derivative functions. this is unique to the left nullspace formulation, as the functions become mixed together
int max_degree;
nullspace_config_setup_right(ns_config,
pi,
ambient_dim,
&max_degree,
randomizer,
W,
solve_options);
if (max_degree==0) {
// this will probably need tweaking when the dimension is higher than 1. but who really is going to decompose a linear surface?
solve_out.copy_patches(W);
ns_concluding_modifications(solve_out, W, ns_config);
std::cout << "the highest degree of any derivative equation is 0. Returning empty SolverOutput." << std::endl;
//then there cannot possibly be any critical points, with respect to ANY projection. simply return an empty but complete set.
return 0;
}
//
///
///// end setup
////////
//////////////
///////////////////////////
int offset;
WitnessSet Wtemp, Wtemp2;
// 2. Do a bunch of homotopies in $x$, each set of which will be followed by a single linear solve in $v$.
if (program_options.verbose_level()>=3) {
std::cout << "building up linprod start system for left nullspace" << std::endl;
}
// setup for the multilin moves
// these are for feeding into the multilin solver -- and that's it. the majority will be overridden in the while loop as the start x linears
vec_mp *multilin_linears = (vec_mp *) br_malloc(W.num_linears()*sizeof(vec_mp)); // target dim is the number of linears in the input witness set
for (unsigned int ii=0; ii<W.num_linears(); ii++) {
init_vec_mp2(multilin_linears[ii],W.num_variables(), solve_options.T.AMP_max_prec);
multilin_linears[ii]->size = W.num_variables();
vec_cp_mp(multilin_linears[ii], W.linear(ii));
}
MultilinConfiguration ml_config(solve_options,randomizer);
// this is for performing the matrix inversion to get ahold of the $v$ values corresponding to $x$
mat_mp tempmat; init_mat_mp2(tempmat, ns_config->num_v_vars, ns_config->num_v_vars,solve_options.T.AMP_max_prec);
tempmat->rows = tempmat->cols = ns_config->num_v_vars;
offset = ns_config->num_v_vars-1;
for (int jj=0; jj<ns_config->num_v_vars; jj++)
set_mp(&tempmat->entry[offset][jj], &ns_config->v_patch->coord[jj]);
// for holding the result of the matrix inversion
vec_mp result; init_vec_mp2(result,ns_config->num_v_vars,solve_options.T.AMP_max_prec); result->size = ns_config->num_v_vars;
// use this for the matrix inversion
vec_mp invert_wrt_me;
init_vec_mp2(invert_wrt_me,ns_config->num_v_vars,solve_options.T.AMP_max_prec); invert_wrt_me->size = ns_config->num_v_vars;
for (int ii=0; ii<ns_config->num_v_vars-1; ii++)
set_zero_mp(&invert_wrt_me->coord[ii]); // set zero
set_one_mp(&invert_wrt_me->coord[ns_config->num_v_vars-1]); // the last entry is set to 1 for the patch equation
vec_mp temppoint; init_vec_mp2(temppoint, ns_config->num_natural_vars +ns_config->num_synth_vars + ns_config->num_v_vars,solve_options.T.AMP_max_prec);
temppoint->size = ns_config->num_natural_vars + ns_config->num_synth_vars + ns_config->num_v_vars;
WitnessSet W_step_one;
W_step_one.set_num_variables(W.num_variables());
W_step_one.set_num_natural_variables(W.num_natural_variables());
W_step_one.copy_patches(W);
W_step_one.copy_names(W);
WitnessSet W_linprod;
W_linprod.set_num_variables(ns_config->num_natural_vars + ns_config->num_v_vars + ns_config->num_synth_vars);
W_linprod.set_num_natural_variables(W.num_natural_variables());
if (program_options.quick_run()<=1)
solve_options.robust = true;
else
solve_options.robust = false;
for (int ii=0; ii<randomizer->num_rand_funcs(); ii++) {
int differentiated_degree = randomizer->randomized_degree(ii)-1; // the -1 is for differentiating. this could be 0.
if (differentiated_degree==0) {
continue;
}
else{
for (int jj=0; jj<differentiated_degree; jj++) {
//copy in the linear for the solve
vec_cp_mp(multilin_linears[0], ns_config->starting_linears[ii][jj]);
// the remainder of the linears are left alone (stay stationary).
if (program_options.verbose_level()>=6) {
std::cout << "moving FROM this set:\n";
for (unsigned int ii=0; ii<W.num_linears(); ii++) {
print_point_to_screen_matlab(W.linear(ii),"L");
}
std::cout << "\nTO this set:\n";
for (unsigned int ii=0; ii<W.num_linears(); ii++) {
print_point_to_screen_matlab(multilin_linears[ii],"ELL");
}
}
// actually solve WRT the linears
SolverOutput fillme;
multilin_solver_master_entry_point(W, // WitnessSet
fillme, // the new data is put here!
multilin_linears,
ml_config,
solve_options);
WitnessSet Wtemp;
fillme.get_noninfinite_w_mult_full(Wtemp); // should be ordered
W_step_one.merge(Wtemp, &solve_options.T);
Wtemp.reset();
}
int curr_index = 0;
for (int kk=0; kk<ns_config->num_v_vars; kk++) { // subtract one from upper limit because of the patch equation
if (kk!=ii) {
for (int mm=0; mm<ns_config->num_v_vars; mm++){
set_mp(&tempmat->entry[curr_index][mm], &ns_config->v_linears[kk]->coord[mm]);}
curr_index++;
}
}
// invert the matrix for the v variables.
matrixSolve_mp(result, tempmat, invert_wrt_me);
//set the bottom part of the temppoint, which will be a startpoint for the nullspace call later.
offset = ns_config->num_natural_vars+ns_config->num_synth_vars;
for (int mm=0; mm<ns_config->num_v_vars; mm++)
set_mp(&temppoint->coord[mm+offset], &result->coord[mm]);
//set the top part, x, of the start point, and copy it in.
for (unsigned int kk=0; kk<W_step_one.num_points(); kk++) {
for (int mm=0; mm<ns_config->num_natural_vars+ns_config->num_synth_vars; mm++) {
set_mp(&temppoint->coord[mm], & W_step_one.point(kk)->coord[mm]);
}
W_linprod.add_point(temppoint);
}
W_step_one.reset();
W_step_one.set_num_variables(W.num_variables());
W_step_one.set_num_natural_variables(W.num_natural_variables());
W_step_one.copy_patches(W); // necessary?
W_step_one.copy_names(W); // necessary?
}
}
for (int ii=0; ii<1; ii++)
clear_vec_mp(multilin_linears[ii]);
free(multilin_linears);
clear_vec_mp(temppoint);
int num_before = W_linprod.num_points();
W_linprod.sort_for_unique(&solve_options.T);
if (num_before - W_linprod.num_points()>0) {
std::cout << "there were non-unique start points" << std::endl;
mypause();
}
W_linprod.set_num_natural_variables(ns_config->num_v_vars+ns_config->num_synth_vars);
W_linprod.copy_patches(W);
W_linprod.copy_names(W);
//set some solver options
if (program_options.quick_run()<=0)
solve_options.robust = true;
else
solve_options.robust = false;
solve_options.use_midpoint_checker = 0;
if (program_options.verbose_level()>=6)
ns_config->print();
if (program_options.verbose_level()>=3) {
std::cout << "running nullspace right method" << std::endl;
}
nullspacejac_solver_master_entry_point(solve_options.T.MPType,
W_linprod, // carries with it the start points, but not the linears.
solve_out, // the created data goes in here.
ns_config,
solve_options);
ns_concluding_modifications(solve_out, W, ns_config);
clear_mat_mp(tempmat);
clear_vec_mp(invert_wrt_me);
clear_vec_mp(result);
return SUCCESSFUL;
}
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;
}
//this derived from basic_eval_d
int sphere_eval_mp(point_mp funcVals, point_mp parVals, vec_mp parDer, mat_mp Jv, mat_mp Jp, point_mp current_variable_values, comp_mp pathVars, void const *ED)
{ // evaluates a special homotopy type, built for bertini_real
// print_comp_mp_matlab(pathVars,"pathvars");
sphere_eval_data_mp *BED = (sphere_eval_data_mp *)ED; // to avoid having to cast every time
BED->SLP_memory.set_globals_to_this();
int ii, jj, mm; // counters
int offset;
comp_mp one_minus_s, gamma_s;
comp_mp temp, temp2;
comp_mp func_val_sphere, func_val_start;
init_mp(one_minus_s); init_mp(gamma_s);
init_mp(temp); init_mp(temp2);
init_mp(func_val_start);
init_mp(func_val_sphere);
set_one_mp(one_minus_s);
sub_mp(one_minus_s, one_minus_s, pathVars); // one_minus_s = (1 - s)
mul_mp(gamma_s, BED->gamma, pathVars); // gamma_s = gamma * s
vec_mp patchValues; init_vec_mp(patchValues, 0);
vec_mp temp_function_values; init_vec_mp(temp_function_values,0);
vec_mp AtimesF; init_vec_mp(AtimesF,BED->randomizer()->num_rand_funcs()); AtimesF->size = BED->randomizer()->num_rand_funcs();// declare // initialize
mat_mp temp_jacobian_functions; init_mat_mp(temp_jacobian_functions,BED->randomizer()->num_base_funcs(),BED->num_variables);
temp_jacobian_functions->rows = BED->randomizer()->num_base_funcs(); temp_jacobian_functions->cols = BED->num_variables;
mat_mp temp_jacobian_parameters; init_mat_mp(temp_jacobian_parameters,0,0);
mat_mp Jv_Patch; init_mat_mp(Jv_Patch, 0, 0);
mat_mp AtimesJ; init_mat_mp(AtimesJ,BED->randomizer()->num_rand_funcs(),BED->num_variables);
AtimesJ->rows = BED->randomizer()->num_rand_funcs(); AtimesJ->cols = BED->num_variables;
//set the sizes
change_size_vec_mp(funcVals,BED->num_variables); funcVals->size = BED->num_variables;
change_size_mat_mp(Jv, BED->num_variables, BED->num_variables); Jv->rows = Jv->cols = BED->num_variables; // -> this should be square!!!
for (ii=0; ii<BED->num_variables; ii++)
for (jj=0; jj<BED->num_variables; jj++)
set_zero_mp(&Jv->entry[ii][jj]);
// evaluate the SLP to get the system's whatnot.
evalProg_mp(temp_function_values, parVals, parDer, temp_jacobian_functions, temp_jacobian_parameters, current_variable_values, pathVars, BED->SLP);
// evaluate the patch
patch_eval_mp(patchValues, parVals, parDer, Jv_Patch, Jp, current_variable_values, pathVars, &BED->patch); // Jp is ignored
// we assume that the only parameter is s = t and setup parVals & parDer accordingly.
// note that you can only really do this AFTER you are done calling other evaluators.
// set parVals & parDer correctly
// i.e. these must remain here, or below. \/
change_size_point_mp(parVals, 1);
change_size_vec_mp(parDer, 1);
change_size_mat_mp(Jp, BED->num_variables, 1); Jp->rows = BED->num_variables; Jp->cols = 1;
for (ii=0; ii<BED->num_variables; ii++)
set_zero_mp(&Jp->entry[ii][0]);
parVals->size = parDer->size = 1;
set_mp(&parVals->coord[0], pathVars); // s = t
set_one_mp(&parDer->coord[0]); // ds/dt = 1
///////////////////////////
//
// the original (randomized) functions.
//
///////////////////////////////////
BED->randomizer()->randomize(AtimesF,AtimesJ,temp_function_values,temp_jacobian_functions,¤t_variable_values->coord[0]);
for (ii=0; ii<AtimesF->size; ii++) // for each function, after (real orthogonal) randomization
set_mp(&funcVals->coord[ii], &AtimesF->coord[ii]);
for (ii = 0; ii < BED->randomizer()->num_rand_funcs(); ii++)
for (jj = 0; jj < BED->num_variables; jj++)
set_mp(&Jv->entry[ii][jj],&AtimesJ->entry[ii][jj]);
//Jp is 0 for the equations.
///////////////////
//
// the sphere equation.
//
//////////////////////////
offset = BED->randomizer()->num_rand_funcs();
mul_mp(func_val_sphere, BED->radius, BED->radius);
neg_mp(func_val_sphere, func_val_sphere);
mul_mp(func_val_sphere, func_val_sphere, ¤t_variable_values->coord[0]);
mul_mp(func_val_sphere, func_val_sphere, ¤t_variable_values->coord[0]);
//f_sph = -r^2*h^2
for (int ii=1; ii<BED->num_natural_vars; ii++) {
mul_mp(temp2, &BED->center->coord[ii-1], ¤t_variable_values->coord[0]); // temp2 = c_{i-1}*h
sub_mp(temp, ¤t_variable_values->coord[ii], temp2); // temp = x_i - h*c_{i-1}
mul_mp(temp2, temp, temp); // temp2 = (x_i - h*c_{i-1})^2
add_mp(func_val_sphere, func_val_sphere, temp2); // f_sph += (x_i - h*c_{i-1})^2
}
set_one_mp(func_val_start);
for (mm=0; mm<2; ++mm) {
dot_product_mp(temp, BED->starting_linear[mm], current_variable_values);
mul_mp(func_val_start, func_val_start, temp);
//f_start *= L_i (x)
}
// combine the function values
mul_mp(temp, one_minus_s, func_val_sphere);
mul_mp(temp2, gamma_s, func_val_start);
add_mp(&funcVals->coord[offset], temp, temp2);
// f = (1-t) f_sph + gamma t f_start
//// / / / / / / now the derivatives wrt x
// first we store the derivatives of the target function, the sphere. then we will add the part for the linear product start.
//ddx for sphere
for (int ii=1; ii<BED->num_natural_vars; ii++) {
mul_mp(temp2, &BED->center->coord[ii-1], ¤t_variable_values->coord[0]); // temp2 = c_{i-1}*h
sub_mp(temp, ¤t_variable_values->coord[ii], temp2) // temp = x_i - c_{i-1}*h
mul_mp(&Jv->entry[offset][ii], BED->two, temp); // Jv = 2*(x_i - c_{i-1}*h)
mul_mp(&Jv->entry[offset][ii], &Jv->entry[offset][ii], one_minus_s); // Jv = (1-t)*2*(x_i - c_{i-1}*h)
mul_mp(temp2, &BED->center->coord[ii-1], temp); // temp2 = c_{i-1} * ( x_i - c_{i-1} * h )
add_mp(&Jv->entry[offset][0], &Jv->entry[offset][0], temp2); // Jv[0] += c_{i-1} * ( x_i - c_{i-1} * h )
}
// multiply these entries by (1-t)
// the homogenizing var deriv
mul_mp(temp, ¤t_variable_values->coord[0], BED->radius);
mul_mp(temp, temp, BED->radius); // temp = r^2 h
add_mp(&Jv->entry[offset][0], &Jv->entry[offset][0], temp); // Jv[0] = \sum_{i=1}^n {c_{i-1} * ( x_i - c_{i-1} * h )} + r^2 h
neg_mp(&Jv->entry[offset][0], &Jv->entry[offset][0]); // Jv[0] = -Jv[0]
mul_mp(&Jv->entry[offset][0], &Jv->entry[offset][0], BED->two); // Jv[0] *= 2
mul_mp(&Jv->entry[offset][0], &Jv->entry[offset][0], one_minus_s); // Jv[0] *= (1-t)
// f = \sum{ ( x_i - c_{i-1} * h )^2 } - r^2 h^2
//Jv = -2(1-t) ( \sum_{i=1}^n { c_{i-1} * ( x_i - c_{i-1} * h ) } + r^2 h )
// a hardcoded product rule for the two linears.
for (int ii=0; ii<BED->num_variables; ii++) {
dot_product_mp(temp, BED->starting_linear[0], current_variable_values);
mul_mp(temp, temp, &BED->starting_linear[1]->coord[ii]);
dot_product_mp(temp2, BED->starting_linear[1], current_variable_values);
mul_mp(temp2, temp2, &BED->starting_linear[0]->coord[ii]);
add_mp(temp, temp, temp2);
mul_mp(temp2, temp, gamma_s);
//temp2 = gamma s * (L_1(x) * L_0[ii] + L_0(x) * L_1[ii])
//temp2 now has the value of the derivative of the start system wrt x_i
add_mp(&Jv->entry[offset][ii], &Jv->entry[offset][ii], temp2);
}
// finally, the Jp entry for sphere equation's homotopy.
//Jp = -f_sph + gamma f_start
neg_mp(&Jp->entry[offset][0], func_val_sphere);
mul_mp(temp, BED->gamma, func_val_start);
add_mp(&Jp->entry[offset][0], &Jp->entry[offset][0], temp);
//////////////
//
// function values for the static linears
//
////////////////////
offset++;
for (mm=0; mm<BED->num_static_linears; ++mm) {
dot_product_mp(&funcVals->coord[mm+offset], BED->static_linear[mm], current_variable_values);
}
for (mm=0; mm<BED->num_static_linears; ++mm) {
for (ii=0; ii<BED->num_variables; ii++) {
set_mp(&Jv->entry[offset+mm][ii], &BED->static_linear[mm]->coord[ii]);
}
}
//Jp is 0 for the static linears
//////////////
//
// the entries for the patch equations.
//
////////////////////
if (offset+BED->num_static_linears != BED->num_variables-BED->patch.num_patches) {
std::cout << color::red() << "mismatch in offset!\nleft: " <<
offset+BED->num_static_linears << " right " << BED->num_variables-BED->patch.num_patches << color::console_default() << std::endl;
mypause();
}
offset = BED->num_variables-BED->patch.num_patches;
for (ii=0; ii<BED->patch.num_patches; ii++)
set_mp(&funcVals->coord[ii+offset], &patchValues->coord[ii]);
for (ii = 0; ii<BED->patch.num_patches; ii++) // for each patch equation
{ // Jv = Jv_Patch
for (jj = 0; jj<BED->num_variables; jj++) // for each variable
set_mp(&Jv->entry[ii+offset][jj], &Jv_Patch->entry[ii][jj]);
}
//Jp is 0 for the patch.
// done! yay!
if (BED->verbose_level()==16 || BED->verbose_level()==-16) {
//uncomment to see screen output of important variables at each solve step.
print_comp_matlab(pathVars, "t_mp");
print_comp_matlab(BED->gamma, "gamma_mp");
print_point_to_screen_matlab(current_variable_values,"currvars_mp");
print_point_to_screen_matlab(funcVals,"F_mp");
print_matrix_to_screen_matlab(Jv,"Jv_mp");
print_matrix_to_screen_matlab(Jp,"Jp_mp");
}
BED->SLP_memory.set_globals_null();
clear_mp(temp);
clear_mp(temp2);
clear_mp(gamma_s);
clear_mp(one_minus_s);
clear_mp(func_val_sphere);
clear_mp(func_val_start);
clear_vec_mp(patchValues);
clear_vec_mp(temp_function_values);
clear_vec_mp(AtimesF);
clear_mat_mp(temp_jacobian_functions);
clear_mat_mp(temp_jacobian_parameters);
clear_mat_mp(Jv_Patch);
clear_mat_mp(AtimesJ);
return 0;
}
