def quad_double_cascade_step(dim, embsys, esols, tasks=0): r""" Given in *embsys* an embedded polynomial system and solutions with nonzero slack variables in *esols*, does one step in the homotopy cascade, with quad double precision arithmetic. The dimension of the solution set represented by *embsys* and *esols* is the value of *dim*. The number of tasks in multithreaded path tracking is given by *tasks*. The default zero value of *tasks* indicates no multithreading. The list on return contains witness points on lower dimensional solution components. """ from phcpy.phcpy2c3 import py2c_copy_quaddobl_container_to_start_system from phcpy.phcpy2c3 import py2c_copy_quaddobl_container_to_start_solutions from phcpy.phcpy2c3 import py2c_quaddobl_cascade_homotopy from phcpy.phcpy2c3 import py2c_solve_by_quaddobl_homotopy_continuation from phcpy.phcpy2c3 import py2c_solcon_clear_quaddobl_solutions from phcpy.phcpy2c3 import py2c_copy_quaddobl_target_solutions_to_container from phcpy.interface import store_quaddobl_witness_set from phcpy.interface import load_quaddobl_solutions store_quaddobl_witness_set(len(embsys), dim, embsys, esols) py2c_copy_quaddobl_container_to_start_system() py2c_copy_quaddobl_container_to_start_solutions() py2c_quaddobl_cascade_homotopy() py2c_solve_by_quaddobl_homotopy_continuation(tasks) py2c_solcon_clear_quaddobl_solutions() py2c_copy_quaddobl_target_solutions_to_container() return load_quaddobl_solutions()
def quaddobl_monodromy_breakup(embsys, esols, dim, \ islaurent=0, verbose=True, nbloops=0): r""" Applies the monodromy breakup algorithm in quad double precision to factor the d-dimensional algebraic set represented by the embedded system *embsys* and its solutions *esols*. If the embedded polynomial system is a Laurent system, then islaurent must equal one, the default is zero. If *verbose* is False, then no output is written. If *nbloops* equals zero, then the user is prompted to give the maximum number of loops. """ from phcpy.phcpy2c2 import py2c_factor_set_quaddobl_to_mute from phcpy.phcpy2c2 import py2c_factor_set_quaddobl_to_verbose from phcpy.phcpy2c2 import py2c_factor_quaddobl_assign_labels from phcpy.phcpy2c2 import py2c_factor_initialize_quaddobl_monodromy from phcpy.phcpy2c2 import py2c_factor_initialize_quaddobl_sampler from phcpy.phcpy2c2 import py2c_factor_initialize_quaddobl_Laurent_sampler from phcpy.phcpy2c2 import py2c_factor_quaddobl_trace_grid_diagnostics from phcpy.phcpy2c2 import py2c_factor_set_quaddobl_trace_slice from phcpy.phcpy2c2 import py2c_factor_store_quaddobl_gammas from phcpy.phcpy2c2 import py2c_factor_quaddobl_track_paths from phcpy.phcpy2c2 import py2c_factor_store_quaddobl_solutions from phcpy.phcpy2c2 import py2c_factor_restore_quaddobl_solutions from phcpy.phcpy2c2 import py2c_factor_new_quaddobl_slices from phcpy.phcpy2c2 import py2c_factor_swap_quaddobl_slices from phcpy.phcpy2c2 import py2c_factor_permutation_after_quaddobl_loop from phcpy.phcpy2c2 import py2c_factor_number_of_quaddobl_components from phcpy.phcpy2c2 import py2c_factor_update_quaddobl_decomposition from phcpy.phcpy2c2 import py2c_solcon_write_quaddobl_solutions from phcpy.phcpy2c2 import py2c_solcon_clear_quaddobl_solutions from phcpy.interface import store_quaddobl_witness_set from phcpy.interface import store_quaddobl_laurent_witness_set if (verbose): print '... applying monodromy factorization with quad doubles ...' py2c_factor_set_quaddobl_to_verbose() else: py2c_factor_set_quaddobl_to_mute() deg = len(esols) nvar = len(embsys) if (verbose): print 'dim =', dim if (islaurent == 1): store_quaddobl_laurent_witness_set(nvar, dim, embsys, esols) py2c_factor_quaddobl_assign_labels(nvar, deg) py2c_factor_initialize_quaddobl_Laurent_sampler(dim) else: store_quaddobl_witness_set(nvar, dim, embsys, esols) py2c_factor_quaddobl_assign_labels(nvar, deg) py2c_factor_initialize_quaddobl_sampler(dim) if (verbose): py2c_solcon_write_quaddobl_solutions() if (nbloops == 0): strnbloops = raw_input('give the maximum number of loops : ') nbloops = int(strnbloops) py2c_factor_initialize_quaddobl_monodromy(nbloops, deg, dim) py2c_factor_store_quaddobl_solutions() if (verbose): print '... initializing the grid ...' for i in range(1, 3): py2c_factor_set_quaddobl_trace_slice(i) py2c_factor_store_quaddobl_gammas(nvar) py2c_factor_quaddobl_track_paths(islarent) py2c_factor_store_quaddobl_solutions() py2c_factor_restore_quaddobl_solutions() py2c_factor_swap_quaddobl_slices() (err, dis) = py2c_factor_quaddobl_trace_grid_diagnostics() if (verbose): print 'The diagnostics of the trace grid :' print ' largest error on the samples :', err print ' smallest distance between the samples :', dis for i in range(1, nbloops + 1): if (verbose): print '... starting loop %d ...' % i py2c_factor_new_quaddobl_slices(dim, nvar) py2c_factor_store_quaddobl_gammas(nvar) py2c_factor_quaddobl_track_paths(islaurent) py2c_solcon_clear_quaddobl_solutions() py2c_factor_store_quaddobl_gammas(nvar) py2c_factor_quaddobl_track_paths(islaurent) py2c_factor_store_quaddobl_solutions() sprm = py2c_factor_permutation_after_quaddobl_loop(deg) if (verbose): perm = eval(sprm) print 'the permutation :', perm nb0 = py2c_factor_number_of_quaddobl_components() done = py2c_factor_update_quaddobl_decomposition(deg, len(sprm), sprm) nb1 = py2c_factor_number_of_quaddobl_components() if (verbose): print 'number of factors : %d -> %d' % (nb0, nb1) deco = decomposition(deg, 'qd') print 'decomposition :', deco if (done == 1): break py2c_factor_restore_quaddobl_solutions()