def quad_double_cascade_step(dim, embsys, esols, tasks=0): r""" Given in *embsys* an embedded polynomial system and solutions with nonzero slace 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.phcpy2c2 import py2c_copy_quaddobl_container_to_start_system from phcpy.phcpy2c2 import py2c_copy_quaddobl_container_to_start_solutions from phcpy.phcpy2c2 import py2c_quaddobl_cascade_homotopy from phcpy.phcpy2c2 import py2c_solve_by_quaddobl_homotopy_continuation from phcpy.phcpy2c2 import py2c_solcon_clear_quaddobl_solutions from phcpy.phcpy2c2 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_system(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_start_diagonal_cascade(gamma=0, tasks=0): r""" Does the path tracking to start a diagonal cascade in quad double precision. For this to work, the functions quaddobl_diagonal_homotopy and quaddobl_diagonal_cascade_solutions must be executed successfully. If *gamma* equals 0 on input, then a random *gamma* constant is generated, otherwise, the given complex *gamma* will be used in the homotopy. Multitasking is available, and is activated by the *tasks* parameter. Returns the target (system and its corresponding) solutions. """ from phcpy.phcpy2c2 import py2c_create_quaddobl_homotopy from phcpy.phcpy2c2 import py2c_create_quaddobl_homotopy_with_gamma from phcpy.phcpy2c2 import py2c_solve_by_quaddobl_homotopy_continuation from phcpy.phcpy2c2 import py2c_solcon_clear_quaddobl_solutions from phcpy.phcpy2c2 import py2c_syscon_clear_quaddobl_system from phcpy.phcpy2c2 import py2c_copy_quaddobl_target_solutions_to_container from phcpy.phcpy2c2 import py2c_copy_quaddobl_target_system_to_container from phcpy.interface import load_quaddobl_solutions from phcpy.interface import load_quaddobl_system if (gamma == 0): py2c_create_quaddobl_homotopy() else: py2c_create_quaddobl_homotopy_with_gamma(gamma.real, gamma.imag) py2c_solve_by_quaddobl_homotopy_continuation(tasks) py2c_solcon_clear_quaddobl_solutions() py2c_syscon_clear_quaddobl_system() py2c_copy_quaddobl_target_solutions_to_container() # from phcpy.phcpy2c2 import py2c_write_quaddobl_target_system # print 'the quaddobl target system :' # py2c_write_quaddobl_target_system() py2c_copy_quaddobl_target_system_to_container() tsys = load_quaddobl_system() sols = load_quaddobl_solutions() return (tsys, sols)
def quaddobl_start_diagonal_cascade(gamma=0, tasks=0): r""" Does the path tracking to start a diagonal cascade in quad double precision. For this to work, the functions quaddobl_diagonal_homotopy and quaddobl_diagonal_cascade_solutions must be executed successfully. If *gamma* equals 0 on input, then a random *gamma* constant is generated, otherwise, the given complex *gamma* will be used in the homotopy. Multitasking is available, and is activated by the *tasks* parameter. Returns the target (system and its corresponding) solutions. """ from phcpy.phcpy2c2 import py2c_create_quaddobl_homotopy from phcpy.phcpy2c2 import py2c_create_quaddobl_homotopy_with_gamma from phcpy.phcpy2c2 import py2c_solve_by_quaddobl_homotopy_continuation from phcpy.phcpy2c2 import py2c_solcon_clear_quaddobl_solutions from phcpy.phcpy2c2 import py2c_syscon_clear_quaddobl_system from phcpy.phcpy2c2 import py2c_copy_quaddobl_target_solutions_to_container from phcpy.phcpy2c2 import py2c_copy_quaddobl_target_system_to_container from phcpy.interface import load_quaddobl_solutions from phcpy.interface import load_quaddobl_system if(gamma == 0): py2c_create_quaddobl_homotopy() else: py2c_create_quaddobl_homotopy_with_gamma(gamma.real, gamma.imag) py2c_solve_by_quaddobl_homotopy_continuation(tasks) py2c_solcon_clear_quaddobl_solutions() py2c_syscon_clear_quaddobl_system() py2c_copy_quaddobl_target_solutions_to_container() # from phcpy.phcpy2c2 import py2c_write_quaddobl_target_system # print 'the quaddobl target system :' # py2c_write_quaddobl_target_system() py2c_copy_quaddobl_target_system_to_container() tsys = load_quaddobl_system() sols = load_quaddobl_solutions() return (tsys, sols)
def quaddobl_solve(pols, silent=False, tasks=0): """ Calls the blackbox solver. On input in pols is a list of strings. By default, the solver will print to screen the computed root counts. To make the solver silent, set the flag silent to True. The number of tasks for multithreading is given by tasks. The solving happens in quad double precision arithmetic. """ from phcpy.phcpy2c2 import py2c_syscon_clear_quaddobl_Laurent_system from phcpy.phcpy2c2 \ import py2c_syscon_initialize_number_of_quaddobl_Laurentials from phcpy.phcpy2c2 import py2c_syscon_store_quaddobl_Laurential from phcpy.phcpy2c2 import py2c_solcon_clear_quaddobl_solutions from phcpy.phcpy2c2 import py2c_solve_quaddobl_Laurent_system from phcpy.interface import load_quaddobl_solutions py2c_syscon_clear_quaddobl_Laurent_system() py2c_solcon_clear_quaddobl_solutions() dim = len(pols) py2c_syscon_initialize_number_of_quaddobl_Laurentials(dim) for ind in range(0, dim): pol = pols[ind] nchar = len(pol) py2c_syscon_store_quaddobl_Laurential(nchar, dim, ind+1, pol) py2c_solve_quaddobl_Laurent_system(silent, tasks) return load_quaddobl_solutions()
def quaddobl_littlewood_richardson_homotopies( ndim, kdim, brackets, verbose=True, vrfcnd=False, minrep=True, tosqr=False, outputfilename="" ): r""" In n-dimensional space we consider k-dimensional planes, subject to intersection conditions represented by brackets. The parameters *ndim* and *kdim* give values for n and k respectively. The parameter brackets is a list of brackets. A bracket is a list of as many natural numbers (in the range 1..*ndim*) as *kdim*. The Littlewood-Richardson homotopies compute k-planes that meet the flags at spaces of dimensions prescribed by the brackets, in quad double precision. Four options are passed as Booleans: *verbose*: for adding extra output during computations, *vrfcnd*: for extra diagnostic verification of Schubert conditions, *minrep*: for a minimial representation of the problem formulation, *tosqr*: to square the overdetermined systems. On return is a 4-tuple. The first item of the tuple is the formal root count, sharp for general flags, then as second item the coordinates of the flags. The coordinates of the flags are stored row wise in a list of real and imaginary parts. The third and fourth item of the tuple on return are respectively the polynomial system that has been solved and its solutions. The length of the list of solution should match the root count. """ from phcpy.phcpy2c2 import py2c_solcon_clear_quaddobl_solutions from phcpy.phcpy2c2 import py2c_schubert_quaddobl_littlewood_richardson_homotopies as qdlrhom from phcpy.interface import load_quaddobl_solutions, load_quaddobl_system py2c_solcon_clear_quaddobl_solutions() nbc = len(brackets) cds = "" for bracket in brackets: for num in bracket: cds = cds + " " + str(num) # print 'the condition string :', cds (roco, sflags) = qdlrhom( ndim, kdim, nbc, len(cds), cds, int(verbose), int(vrfcnd), int(minrep), int(tosqr), len(outputfilename), outputfilename, ) rflags = eval(sflags) flgs = [] for k in range(len(rflags) / 8): flgs.append(complex(rflags[2 * k], rflags[2 * k + 4])) fsys = load_quaddobl_system() sols = load_quaddobl_solutions() return (roco, flgs, fsys, sols)
def quaddobl_littlewood_richardson_homotopies(ndim, kdim, brackets, \ verbose=True, vrfcnd=False, minrep=True, tosqr=False, outputfilename=''): r""" In n-dimensional space we consider k-dimensional planes, subject to intersection conditions represented by brackets. The parameters *ndim* and *kdim* give values for n and k respectively. The parameter brackets is a list of brackets. A bracket is a list of as many natural numbers (in the range 1..*ndim*) as *kdim*. The Littlewood-Richardson homotopies compute k-planes that meet the flags at spaces of dimensions prescribed by the brackets, in quad double precision. Four options are passed as Booleans: *verbose*: for adding extra output during computations, *vrfcnd*: for extra diagnostic verification of Schubert conditions, *minrep*: for a minimial representation of the problem formulation, *tosqr*: to square the overdetermined systems. On return is a 4-tuple. The first item of the tuple is the formal root count, sharp for general flags, then as second item the coordinates of the flags. The coordinates of the flags are stored row wise in a list of real and imaginary parts. The third and fourth item of the tuple on return are respectively the polynomial system that has been solved and its solutions. The length of the list of solution should match the root count. """ from phcpy.phcpy2c2 import py2c_solcon_clear_quaddobl_solutions from phcpy.phcpy2c2 \ import py2c_schubert_quaddobl_littlewood_richardson_homotopies \ as qdlrhom from phcpy.interface import load_quaddobl_solutions, load_quaddobl_system py2c_solcon_clear_quaddobl_solutions() nbc = len(brackets) cds = '' for bracket in brackets: for num in bracket: cds = cds + ' ' + str(num) # print 'the condition string :', cds (roco, sflags) = qdlrhom(ndim, kdim, nbc, len(cds), cds, \ int(verbose), int(vrfcnd), int(minrep), int(tosqr), \ len(outputfilename), outputfilename) rflags = eval(sflags) flgs = [] for k in range(len(rflags) / 8): flgs.append(complex(rflags[2 * k], rflags[2 * k + 4])) fsys = load_quaddobl_system() sols = load_quaddobl_solutions() return (roco, flgs, fsys, sols)
def store_quaddobl_solutions(nvar, sols): """ Stores the solutions in the list sols, represented as strings in PHCpack format into the solution container for processing with complex quad double arithmetic. The number n equals the number of variables. """ from phcpy.phcpy2c2 import py2c_solcon_clear_quaddobl_solutions from phcpy.phcpy2c2 import py2c_solcon_append_quaddobl_solution_string py2c_solcon_clear_quaddobl_solutions() for ind in range(0, len(sols)): fail = py2c_solcon_append_quaddobl_solution_string\ (nvar, len(sols[ind]), sols[ind]) if(fail != 0): break return fail
def quad_double_track(target, start, sols, gamma=0, tasks=0): r""" Does path tracking with quad double precision. On input are a *target* system, a *start* system with solutions, optionally a (random) *gamma* constant and the number of *tasks*. The default value zero for *tasks* indicates no multithreading. The number of tasks in the multithreading is given by *tasks*. The *target* is a list of strings representing the polynomials of the target system (which has to be solved). The *start* is a list of strings representing the polynomials of the start system with known solutions in *sols*. The *sols* is a list of strings representing start solutions. By default, a random *gamma* constant is generated, otherwise *gamma* must be a nonzero complex constant. On return are the string representations of the solutions computed at the end of the paths. """ from phcpy.phcpy2c2 import py2c_copy_quaddobl_container_to_target_system from phcpy.phcpy2c2 import py2c_copy_quaddobl_container_to_start_system from phcpy.phcpy2c2 import py2c_copy_quaddobl_container_to_start_solutions from phcpy.phcpy2c2 import py2c_create_quaddobl_homotopy from phcpy.phcpy2c2 import py2c_create_quaddobl_homotopy_with_gamma from phcpy.phcpy2c2 import py2c_solve_by_quaddobl_homotopy_continuation from phcpy.phcpy2c2 import py2c_solcon_clear_quaddobl_solutions from phcpy.phcpy2c2 import py2c_copy_quaddobl_target_solutions_to_container from phcpy.interface import store_quaddobl_system from phcpy.interface import store_quaddobl_solutions from phcpy.interface import load_quaddobl_solutions from phcpy.solver import number_of_symbols dim = number_of_symbols(start) store_quaddobl_system(target, nbvar=dim) py2c_copy_quaddobl_container_to_target_system() store_quaddobl_system(start, nbvar=dim) py2c_copy_quaddobl_container_to_start_system() # py2c_clear_quaddobl_homotopy() if(gamma == 0): py2c_create_quaddobl_homotopy() else: py2c_create_quaddobl_homotopy_with_gamma(gamma.real, gamma.imag) store_quaddobl_solutions(dim, sols) py2c_copy_quaddobl_container_to_start_solutions() py2c_solve_by_quaddobl_homotopy_continuation(tasks) py2c_solcon_clear_quaddobl_solutions() py2c_copy_quaddobl_target_solutions_to_container() return load_quaddobl_solutions()
def store_quaddobl_solutions(nvar, sols): r""" Stores the solutions in the list *sols*, represented as strings in PHCpack format into the solution container for processing with complex quad double arithmetic. The number *nvar* equals the number of variables. """ from phcpy.phcpy2c2 import py2c_solcon_clear_quaddobl_solutions from phcpy.phcpy2c2 import py2c_solcon_append_quaddobl_solution_string py2c_solcon_clear_quaddobl_solutions() fail = 0 for ind in range(0, len(sols)): fail = py2c_solcon_append_quaddobl_solution_string\ (nvar, len(sols[ind]), sols[ind]) if (fail != 0): # break print 'Solution at position', ind, 'is not appended.' return fail
def store_quaddobl_solutions(nvar, sols): r""" Stores the solutions in the list *sols*, represented as strings in PHCpack format into the solution container for processing with complex quad double arithmetic. The number *nvar* equals the number of variables. """ from phcpy.phcpy2c2 import py2c_solcon_clear_quaddobl_solutions from phcpy.phcpy2c2 import py2c_solcon_append_quaddobl_solution_string py2c_solcon_clear_quaddobl_solutions() fail = 0 for ind in range(0, len(sols)): fail = py2c_solcon_append_quaddobl_solution_string\ (nvar, len(sols[ind]), sols[ind]) if(fail != 0): # break print 'Solution at position', ind, 'is not appended.' return fail
def quad_double_track(target, start, sols, gamma=0, tasks=0): """ Does path tracking with quad double precision. On input are a target system, a start system with solutions, optionally a (random) gamma constant and the number of tasks. The target is a list of strings representing the polynomials of the target system (which has to be solved). The start is a list of strings representing the polynomials of the start system with known solutions in sols. The sols is a list of strings representing start solutions. By default, a random gamma constant is generated, otherwise gamma must be a nonzero complex constant. On return are the string representations of the solutions computed at the end of the paths. """ from phcpy.phcpy2c2 import py2c_copy_quaddobl_container_to_target_system from phcpy.phcpy2c2 import py2c_copy_quaddobl_container_to_start_system from phcpy.phcpy2c2 import py2c_copy_quaddobl_container_to_start_solutions from phcpy.phcpy2c2 import py2c_create_quaddobl_homotopy from phcpy.phcpy2c2 import py2c_create_quaddobl_homotopy_with_gamma from phcpy.phcpy2c2 import py2c_solve_by_quaddobl_homotopy_continuation from phcpy.phcpy2c2 import py2c_solcon_clear_quaddobl_solutions from phcpy.phcpy2c2 import py2c_copy_quaddobl_target_solutions_to_container from phcpy.interface import store_quaddobl_system from phcpy.interface import store_quaddobl_solutions from phcpy.interface import load_quaddobl_solutions from phcpy.solver import number_of_symbols dim = number_of_symbols(start) store_quaddobl_system(target, nbvar=dim) py2c_copy_quaddobl_container_to_target_system() store_quaddobl_system(start, nbvar=dim) py2c_copy_quaddobl_container_to_start_system() # py2c_clear_quaddobl_homotopy() if(gamma == 0): py2c_create_quaddobl_homotopy() else: py2c_create_quaddobl_homotopy_with_gamma(gamma.real, gamma.imag) store_quaddobl_solutions(dim, sols) py2c_copy_quaddobl_container_to_start_solutions() 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_littlewood_richardson_homotopies(ndim, kdim, brackets, \ verbose=True, vrfcnd=False, outputfilename='/tmp/output'): """ In n-dimensional space we consider k-dimensional planes, subject to intersection conditions represented by brackets. The parameters ndim and kdim give values for n and k respectively. The parameter brackets is a list of brackets. A bracket is a list of as many natural numbers (in the range 1..ndim) as kdim. The Littlewood-Richardson homotopies compute k-planes that meet the flags at spaces of dimensions prescribed by the brackets, in quad double precision. On return is a 4-tuple. The first item of the tuple is the formal root count, sharp for general flags, then as second item the coordinates of the flags. The coordinates of the flags are stored row wise in a list of real and imaginary parts. The third and fourth item of the tuple on return are respectively the polynomial system that has been solved and its solutions. The length of the list of solution should match the root count. """ from phcpy.phcpy2c2 import py2c_solcon_clear_quaddobl_solutions from phcpy.phcpy2c2 \ import py2c_schubert_quaddobl_littlewood_richardson_homotopies \ as qdlrhom from phcpy.interface import load_quaddobl_solutions, load_quaddobl_system py2c_solcon_clear_quaddobl_solutions() nbc = len(brackets) cds = '' for bracket in brackets: for num in bracket: cds = cds + ' ' + str(num) # print 'the condition string :', cds (roco, sflags) = qdlrhom(ndim, kdim, nbc, len(cds), cds, int(verbose), \ int(vrfcnd), len(outputfilename), outputfilename) rflags = eval(sflags) flgs = [] for k in range(len(rflags)/8): flgs.append(complex(rflags[2*k], rflags[2*k+4])) fsys = load_quaddobl_system() sols = load_quaddobl_solutions() return (roco, flgs, fsys, sols)
def quaddobl_random_coefficient_system(silent=False): """ Runs the polyhedral homotopies and returns a random coefficient system based on the contents of the cell container, in quad double precision arithmetic. For this to work, the mixed_volume function must be called first. """ from phcpy.phcpy2c2 import py2c_celcon_quaddobl_random_coefficient_system from phcpy.phcpy2c2 import py2c_celcon_copy_into_quaddobl_systems_container from phcpy.phcpy2c2 import py2c_celcon_quaddobl_polyhedral_homotopy from phcpy.phcpy2c2 import py2c_celcon_number_of_cells from phcpy.phcpy2c2 import py2c_solcon_clear_quaddobl_solutions from phcpy.phcpy2c2 import py2c_celcon_solve_quaddobl_start_system from phcpy.phcpy2c2 import py2c_celcon_track_quaddobl_solution_path from phcpy.phcpy2c2 \ import py2c_celcon_copy_target_quaddobl_solution_to_container from phcpy.interface import load_quaddobl_system, load_quaddobl_solutions py2c_celcon_quaddobl_random_coefficient_system() py2c_celcon_copy_into_quaddobl_systems_container() # py2c_syscon_write_dobldobl_system() result = load_quaddobl_system() # print result py2c_celcon_quaddobl_polyhedral_homotopy() nbcells = py2c_celcon_number_of_cells() py2c_solcon_clear_quaddobl_solutions() for cell in range(1, nbcells+1): mixvol = py2c_celcon_solve_quaddobl_start_system(cell) if not silent: print 'system %d has %d solutions' % (cell, mixvol) for j in range(1, mixvol+1): if not silent: print '-> tracking path %d out of %d' % (j, mixvol) py2c_celcon_track_quaddobl_solution_path(cell, j, 0) py2c_celcon_copy_target_quaddobl_solution_to_container(cell, j) sols = load_quaddobl_solutions() # print sols # newton_step(result, sols) return (result, sols)
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 *dim*-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_solutions from phcpy.interface import store_quaddobl_system from phcpy.interface import store_quaddobl_laurent_system 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) store_quaddobl_solutions(nvar, esols) if(islaurent == 1): store_quaddobl_laurent_system(embsys) py2c_factor_quaddobl_assign_labels(nvar, deg) py2c_factor_initialize_quaddobl_Laurent_sampler(dim) else: store_quaddobl_system(embsys) py2c_factor_quaddobl_assign_labels(nvar, deg) py2c_factor_initialize_quaddobl_sampler(dim) if(verbose): py2c_solcon_write_quaddobl_solutions() if(nbloops == 0): strnbloops = 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(islaurent) 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()