int quaddobl_run ( int myid, int nbrp, int nbc, char* outfile, int verbose )
{
int fail,dim,nbsols,mysolnum,len,*nbpaths;
double startwtime,endwtime,wtime,*time;
startwtime = MPI_Wtime();
if(myid == 0)
{
time = (double*)calloc(nbrp,sizeof(double));
nbpaths = (int*)calloc(nbrp,sizeof(int));
fail = read_quaddobl_target_system_without_solutions();
fail = copy_quaddobl_target_system_to_container();
fail = syscon_number_of_quaddobl_polynomials(&dim);
fail = write_quaddobl_target_system();
}
quaddobl_dimensions_broadcast(myid,&dim,&dim);
if(verbose > 0) printf("Process %d has dimension %d.\n",myid,dim);
quaddobl_monomials_broadcast(myid,dim);
if(myid != 0) fail = copy_quaddobl_container_to_target_system();
if(verbose > 0)
if(myid == 1) fail = write_quaddobl_target_system();
if(myid == 0)
{
fail = read_quaddobl_start_system();
fail = copy_quaddobl_start_system_to_container();
fail = write_quaddobl_start_system(); // writes to file
fail = write_quaddobl_start_solutions(); // writes solutions to file
fail = copy_quaddobl_start_solutions_to_container();
fail = solcon_number_of_quaddobl_solutions(&nbsols);
if(verbose>0) printf("Read %d start solutions.\n",nbsols);
}
else
fail = syscon_initialize_number_of_quaddobl_polynomials(dim);
quaddobl_monomials_broadcast(myid,dim); // broadcast start system
if(myid != 0) fail = copy_quaddobl_container_to_start_system();
if(verbose > 0)
if(myid == 1) fail = write_quaddobl_start_system();
parameters_broadcast(myid,nbrp,1);
MPI_Bcast(&nbsols,1,MPI_INT,0,MPI_COMM_WORLD);
quaddobl_solutions_distribute(myid,nbsols,dim,nbrp,&mysolnum,verbose);
fail = solcon_number_of_quaddobl_solutions(&len);
if(verbose > 0) printf("Node %d has %d solutions.\n",myid,len);
if(myid > 0)
{
fail = copy_quaddobl_container_to_start_solutions();
fail = quaddobl_track_paths(myid,nbrp,nbc,outfile,verbose);
}
quaddobl_solutions_collect(myid,nbsols,dim,nbrp,mysolnum);
if(myid == 0)
{
fail = copy_quaddobl_container_to_target_solutions();
fail = write_quaddobl_target_solutions();
}
endwtime = MPI_Wtime();
wtime = endwtime-startwtime;
MPI_Gather(&wtime,1,MPI_DOUBLE,time,1,MPI_DOUBLE,0,MPI_COMM_WORLD);
MPI_Gather(&mysolnum,1,MPI_INT,nbpaths,1,MPI_INT,0,MPI_COMM_WORLD);
if(myid == 0)
{
nbpaths[0] = nbsols;
write_time_and_paths_to_defined_output_file(nbrp,time,nbpaths);
free(time); free(nbpaths);
}
return 0;
}
int quaddobl_monodromy_breakup ( int nbloops, int n, int k, int d )
{
int fail,i,j,done;
double err,dis;
fail = initialize_quaddobl_sampler(k);
fail = initialize_quaddobl_monodromy(nbloops,d,k);
if(verbose>0)
printf("\nInitialized sampler and monodromy permutations ...\n");
fail = store_quaddobl_solutions(); /* store in monodromy permutations */
printf("... initializing the grid in quad double precision ...\n");
for(i=1; i<=2; i++) /* initialize grid for trace validation */
{
fail = set_quaddobl_trace_slice(i); /* fix constant of slice */
fail = store_quaddobl_gammas(n); /* generate random gamma constants */
fail = quaddobl_track_paths();
fail = store_quaddobl_solutions(); /* store solutions in the grid */
fail = restore_quaddobl_solutions(); /* use original sols at start */
fail = swap_quaddobl_slices(); /* go back to original slices */
}
fail = quaddobl_trace_grid_diagnostics(&err,&dis);
printf("Trace grid diagnostics : \n");
printf(" largest error of the samples : %.3e\n", err);
printf(" smallest distance between samples : %.3e\n", dis);
done = 0;
for(i=1; (i<=nbloops) && (done==0); i++) /* perform monodromy loops */
{
printf("... starting loop #\%d in quad double precision ...\n",i);
fail = new_quaddobl_slices(k,n);
fail = store_quaddobl_gammas(n);
fail = quaddobl_track_paths(); /* swapping slices happens here */
fail = solcon_clear_quaddobl_solutions();
fail = store_quaddobl_gammas(n);
fail = quaddobl_track_paths();
fail = store_quaddobl_solutions();
{
int permutation[d];
fail = permutation_after_quaddobl_loop(d,permutation);
printf("the permutation at step %d:",i);
for(j=0; j<d; j++) printf(" %d",permutation[j]);
printf("\n");
}
fail = quaddobl_monodromy_permutation(d,&done);
{
int nf,deg,jp,w[d];
double trace_difference;
fail = number_of_quaddobl_factors(&nf);
printf("number of irreducible factors : %d\n",nf);
for(j=1; j<=nf; j++)
{
fail = witness_points_of_quaddobl_factor(j,°,w);
printf(" %d :",j);
for(jp=0; jp<deg; jp++) printf(" %d",w[jp]);
fail = quaddobl_trace_sum_difference(deg,w,&trace_difference);
printf(" : %.3e\n",trace_difference);
}
}
fail = restore_quaddobl_solutions();
}
if(done==1)
printf("Found factorization using %d loops.\n", i-1);
else
printf("Failed to factor using %d loops.\n", i-1);
return fail;
}
