void clear()
{
for (int ii=0; ii<num_linears; ii++) {
clear_vec_d(current_linear[ii]);
clear_vec_d(old_linear[ii]);
}
free(current_linear);
free(old_linear);
if (this->MPType==2)
{
delete this->BED_mp;
}
}
void clear()
{
//yeah, there's some stuff to clear here.
if (this->MPType==2) {
delete this->BED_mp;
}
for (int ii=0; ii<num_projections; ii++) {
clear_vec_d(pi[ii]);
}
free(pi);
} // re: clear
void clear()
{
if (num_additional_linears>0) {
for (int ii=0; ii<num_additional_linears; ii++) {
clear_vec_d(additional_linears_terminal[ii]);
}
free(additional_linears_terminal);
for (int ii=0; ii<num_additional_linears; ii++) {
clear_vec_d(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_d(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_d(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_d(v_linears[ii]);
}
free(v_linears);
}
clear_vec_d(v_patch);
clear_mat_d(jac_with_proj);
if (num_projections>0) {
for (int ii=0; ii<num_projections; ii++) {
clear_vec_d(target_projection[ii]);
}
free(target_projection);
}
if (this->MPType==2) {
delete this->BED_mp;
}
else{
clear_deriv(SLP_derivative);
delete this->SLP_derivative;
}
} // re: clear
int sphere_eval_d(point_d funcVals, point_d parVals, vec_d parDer, mat_d Jv, mat_d Jp,
point_d current_variable_values, comp_d pathVars,
void const *ED)
{ // evaluates a special homotopy type, built for bertini_real
sphere_eval_data_d *BED = (sphere_eval_data_d *)ED; // to avoid having to cast every time
BED->SLP_memory.set_globals_to_this();
int ii, jj, mm; // counters
int offset;
comp_d one_minus_s, gamma_s;
comp_d temp, temp2;
comp_d func_val_sphere, func_val_start;
set_one_d(one_minus_s);
sub_d(one_minus_s, one_minus_s, pathVars); // one_minus_s = (1 - s)
mul_d(gamma_s, BED->gamma, pathVars); // gamma_s = gamma * s
vec_d patchValues; init_vec_d(patchValues, 0);
vec_d temp_function_values; init_vec_d(temp_function_values,0);
vec_d AtimesF; init_vec_d(AtimesF,BED->randomizer()->num_rand_funcs()); AtimesF->size = BED->randomizer()->num_rand_funcs();// declare // initialize
mat_d temp_jacobian_functions; init_mat_d(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_d temp_jacobian_parameters; init_mat_d(temp_jacobian_parameters,0,0);
mat_d Jv_Patch; init_mat_d(Jv_Patch, 0, 0);
mat_d AtimesJ; init_mat_d(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_d(funcVals,BED->num_variables); funcVals->size = BED->num_variables;
change_size_mat_d(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_d(&Jv->entry[ii][jj]);
// evaluate the SLP to get the system's whatnot.
evalProg_d(temp_function_values, parVals, parDer, temp_jacobian_functions, temp_jacobian_parameters, current_variable_values, pathVars, BED->SLP);
// evaluate the patch
patch_eval_d(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_d(parVals, 1);
change_size_vec_d(parDer, 1);
change_size_mat_d(Jp, BED->num_variables, 1); Jp->rows = BED->num_variables; Jp->cols = 1;
for (ii=0; ii<BED->num_variables; ii++)
set_zero_d(&Jp->entry[ii][0]);
parVals->size = parDer->size = 1;
set_d(&parVals->coord[0], pathVars); // s = t
set_one_d(&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_d(&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_d(&Jv->entry[ii][jj],&AtimesJ->entry[ii][jj]);
//Jp is 0 for the equations.
///////////////////
//
// the sphere equation.
//
//////////////////////////
offset = BED->randomizer()->num_rand_funcs();
mul_d(func_val_sphere, BED->radius, BED->radius);
neg_d(func_val_sphere, func_val_sphere);
mul_d(func_val_sphere, func_val_sphere, ¤t_variable_values->coord[0]);
mul_d(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_d(temp2, &BED->center->coord[ii-1], ¤t_variable_values->coord[0]); // temp2 = c_{i-1}*h
sub_d(temp, ¤t_variable_values->coord[ii], temp2); // temp = x_i - h*c_{i-1}
mul_d(temp2, temp, temp); // temp2 = (x_i - h*c_{i-1})^2
add_d(func_val_sphere, func_val_sphere, temp2); // f_sph += (x_i - h*c_{i-1})^2
}
set_one_d(func_val_start);
for (mm=0; mm<2; ++mm) {
dot_product_d(temp, BED->starting_linear[mm], current_variable_values);
mul_d(func_val_start, func_val_start, temp);
//f_start *= L_i (x)
}
// combine the function values
mul_d(temp, one_minus_s, func_val_sphere);
mul_d(temp2, gamma_s, func_val_start);
add_d(&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_d(temp2, &BED->center->coord[ii-1], ¤t_variable_values->coord[0]); // temp2 = c_{i-1}*h
sub_d(temp, ¤t_variable_values->coord[ii], temp2) // temp = x_i - c_{i-1}*h
mul_d(&Jv->entry[offset][ii], BED->two, temp); // Jv = 2*(x_i - c_{i-1}*h)
mul_d(&Jv->entry[offset][ii], &Jv->entry[offset][ii], one_minus_s); // Jv = (1-t)*2*(x_i - c_{i-1}*h)
// multiply these entries by (1-t)
mul_d(temp2, &BED->center->coord[ii-1], temp); // temp2 = c_{i-1} * ( x_i - c_{i-1} * h )
add_d(&Jv->entry[offset][0], &Jv->entry[offset][0], temp2); // Jv[0] += c_{i-1} * ( x_i - c_{i-1} * h )
}
// the homogenizing var deriv
mul_d(temp, ¤t_variable_values->coord[0], BED->radius);
mul_d(temp, temp, BED->radius); // temp = r^2 h
add_d(&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_d(&Jv->entry[offset][0], &Jv->entry[offset][0]); // Jv[0] = -Jv[0]
mul_d(&Jv->entry[offset][0], &Jv->entry[offset][0], BED->two); // Jv[0] *= 2
mul_d(&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[0] = -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_d(temp, BED->starting_linear[0], current_variable_values);
mul_d(temp, temp, &BED->starting_linear[1]->coord[ii]);
dot_product_d(temp2, BED->starting_linear[1], current_variable_values);
mul_d(temp2, temp2, &BED->starting_linear[0]->coord[ii]);
add_d(temp, temp, temp2);
mul_d(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_d(&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_d(&Jp->entry[offset][0], func_val_sphere);
mul_d(temp, BED->gamma, func_val_start);
add_d(&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_d(&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_d(&Jv->entry[mm+offset][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_d(&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_d(&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_point_to_screen_matlab(BED->center,"center");
print_comp_matlab(BED->radius,"radius");
printf("gamma = %lf+1i*%lf;\n", BED->gamma->r, BED->gamma->i);
printf("time = %lf+1i*%lf;\n", pathVars->r, pathVars->i);
print_point_to_screen_matlab(current_variable_values,"currvars");
print_point_to_screen_matlab(funcVals,"F");
print_matrix_to_screen_matlab(Jv,"Jv");
print_matrix_to_screen_matlab(Jp,"Jp");
}
BED->SLP_memory.set_globals_null();
clear_vec_d(patchValues);
clear_vec_d(temp_function_values);
clear_vec_d(AtimesF);
clear_mat_d(temp_jacobian_functions);
clear_mat_d(temp_jacobian_parameters);
clear_mat_d(Jv_Patch);
clear_mat_d(AtimesJ);
#ifdef printpathsphere
BED->num_steps++;
vec_d dehommed; init_vec_d(dehommed,BED->num_variables-1); dehommed->size = BED->num_variables-1;
dehomogenize(&dehommed,current_variable_values);
fprintf(BED->FOUT,"%.15lf %.15lf ", pathVars->r, pathVars->i);
for (ii=0; ii<BED->num_variables-1; ++ii) {
fprintf(BED->FOUT,"%.15lf %.15lf ",dehommed->coord[ii].r,dehommed->coord[ii].i);
}
fprintf(BED->FOUT,"\n");
clear_vec_d(dehommed);
#endif
return 0;
}
int check_issoln_sphere_d(endgame_data_t *EG,
tracker_config_t *T,
void const *ED)
{
sphere_eval_data_d *BED = (sphere_eval_data_d *)ED; // to avoid having to cast every time
BED->SLP_memory.set_globals_to_this();
int ii;
double n1, n2, max_rat;
point_d f;
eval_struct_d e;
init_point_d(f, 1);
init_eval_struct_d(e,0, 0, 0);
max_rat = MAX(T->ratioTol,0.99999);
// setup threshold based on given threshold and precision
// if (num_digits > 300)
// num_digits = 300;
// num_digits -= 2;
double tol = MAX(T->funcResTol, 1e-8);
if (EG->prec>=64){
vec_d terminal_pt; init_vec_d(terminal_pt,1);
vec_mp_to_d(terminal_pt,EG->PD_mp.point);
evalProg_d(e.funcVals, e.parVals, e.parDer, e.Jv, e.Jp, terminal_pt, EG->PD_d.time, BED->SLP);
clear_vec_d(terminal_pt);
}
else{
evalProg_d(e.funcVals, e.parVals, e.parDer, e.Jv, e.Jp, EG->PD_d.point, EG->PD_d.time, BED->SLP);
}
if (EG->last_approx_prec>=64) {
vec_d prev_pt; init_vec_d(prev_pt,1);
vec_mp_to_d(prev_pt,EG->PD_mp.point);
evalProg_d(f, e.parVals, e.parDer, e.Jv, e.Jp, prev_pt, EG->PD_d.time, BED->SLP);
clear_vec_d(prev_pt);}
else{
evalProg_d(f, e.parVals, e.parDer, e.Jv, e.Jp, EG->last_approx_d, EG->PD_d.time, BED->SLP);
}
// compare the function values
int isSoln = 1;
for (ii = 0; (ii < BED->SLP->numFuncs) && isSoln; ii++)
{
n1 = d_abs_d( &e.funcVals->coord[ii]); // corresponds to final point
n2 = d_abs_d( &f->coord[ii]); // corresponds to the previous point
if (tol <= n1 && n1 <= n2)
{ // compare ratio
if (n1 > max_rat * n2){
isSoln = 0;
printf("labeled as non_soln due to max_rat (d) 1 coord %d\n",ii);
}
}
else if (tol <= n2 && n2 <= n1)
{ // compare ratio
if (n2 > max_rat * n1){
isSoln = 0;
printf("labeled as non_soln due to max_rat (d) 2 coord %d\n",ii);
}
}
}
if (!isSoln) {
print_point_to_screen_matlab(e.funcVals,"terminal_func_vals");
print_point_to_screen_matlab(f,"prev");
printf("tol was %le\nmax_rat was %le\n",tol,max_rat);
}
clear_eval_struct_d(e);
clear_vec_d(f);
BED->SLP_memory.set_globals_null();
return isSoln;
}
