def quaddobl_laursys_solve(pols, topdim=-1, \ filter=True, factor=True, tasks=0, verbose=True): """ Runs the cascades of homotopies on the Laurent polynomial system in pols in quad double precision. The default top dimension topdim is the number of variables in pols minus one. """ from phcpy.phcpy2c3 import py2c_quaddobl_laursys_solve from phcpy.phcpy2c3 import py2c_copy_quaddobl_laursys_witset from phcpy.solver import number_of_symbols from phcpy.interface import store_quaddobl_laurent_system from phcpy.interface import load_quaddobl_laurent_system from phcpy.interface import load_quaddobl_solutions dim = number_of_symbols(pols) if (topdim == -1): topdim = dim - 1 fail = store_quaddobl_laurent_system(pols, nbvar=dim) fail = py2c_quaddobl_laursys_solve(tasks,topdim, \ int(filter),int(factor),int(verbose)) witsols = [] for soldim in range(0, topdim + 1): fail = py2c_copy_quaddobl_laursys_witset(soldim) witset = (load_quaddobl_laurent_system(), load_quaddobl_solutions()) witsols.append(witset) return witsols
def quaddobl_laursys_solve(pols, topdim=-1, \ filter=True, factor=True, tasks=0, verbose=True): """ Runs the cascades of homotopies on the Laurent polynomial system in pols in quad double precision. The default top dimension topdim is the number of variables in pols minus one. """ from phcpy.phcpy2c3 import py2c_quaddobl_laursys_solve from phcpy.phcpy2c3 import py2c_copy_quaddobl_laursys_witset from phcpy.solver import number_of_symbols from phcpy.interface import store_quaddobl_laurent_system from phcpy.interface import load_quaddobl_laurent_system from phcpy.interface import load_quaddobl_solutions dim = number_of_symbols(pols) if(topdim == -1): topdim = dim - 1 fail = store_quaddobl_laurent_system(pols, nbvar=dim) fail = py2c_quaddobl_laursys_solve(tasks,topdim, \ int(filter),int(factor),int(verbose)) witsols = [] for soldim in range(0, topdim+1): fail = py2c_copy_quaddobl_laursys_witset(soldim) witset = (load_quaddobl_laurent_system(), load_quaddobl_solutions()) witsols.append(witset) return witsols
def canonize(pols): from phcpy.solver import number_of_symbols from phcpy.polytopes import support dim = number_of_symbols(pols) supp = [[list(mon) for mon in support(dim,pol)] for pol in pols] print(supp) return GetUniqueString(CreateNautyString(MakeConstIntoVar(supp)))
def quaddobl_pade_approximants(pols, sols, idx=1, numdeg=2, dendeg=2, \ nbr=4, verbose=True): r""" Computes Pade approximants based on the series in quad double precision for the polynomials in *pols*, where the leading coefficients of the series are the solutions in *sols*. On entry are the following seven parameters: *pols*: a list of string representations of polynomials, *sols*: a list of solutions of the polynomials in *pols*, *idx*: index of the series parameter, by default equals 1, *numdeg*: the degree of the numerator, *dendeg*: the degree of the denominator, *nbr*: number of steps with Newton's method, *verbose*: whether to write intermediate output to screen or not. On return is a list of lists of strings. Each lists of strings represents the series solution for the variables in the list *pols*. """ from phcpy.solver import number_of_symbols from phcpy.interface import store_quaddobl_solutions from phcpy.interface import store_quaddobl_system, load_quaddobl_system from phcpy.phcpy2c3 \ import py2c_quaddobl_Pade_approximant as Pade_approximants from phcpy.phcpy2c3 import py2c_syspool_quaddobl_size as poolsize from phcpy.phcpy2c3 import py2c_syspool_copy_to_quaddobl_container from phcpy.phcpy2c3 import py2c_syspool_quaddobl_clear nbsym = number_of_symbols(pols) if verbose: print("the polynomials :") for pol in pols: print(pol) print("Number of variables :", nbsym) store_quaddobl_system(pols, nbvar=nbsym) store_quaddobl_solutions(nbsym, sols) fail = Pade_approximants(idx, numdeg, dendeg, nbr, int(verbose)) size = (-1 if fail else poolsize()) if verbose: if size == -1: print("An error occurred in the Pade constructor.") else: print("Computed %d Pade approximants." % size) result = [] for k in range(1, size + 1): py2c_syspool_copy_to_quaddobl_container(k) sersol = load_quaddobl_system() substsersol = substitute_symbol(sersol, idx) result.append(make_fractions(substsersol)) py2c_syspool_quaddobl_clear() return result
def quaddobl_newton_power_series(pols, lser, idx=1, nbr=4, verbose=True): r""" Computes series in quad double precision for the polynomials in *pols*, where the leading terms are given in the list *lser*. On entry are the following five parameters: *pols*: a list of string representations of polynomials, *lser*: a list of polynomials in the series parameter (e.g.: t), for use as start terms in Newton's method, *idx*: index of the series parameter, by default equals 1, *nbr*: number of steps with Newton's method, *verbose*: whether to write intermediate output to screen or not. On return is a list of lists of strings. Each lists of strings represents the series solution for the variables in the list *pols*. """ from phcpy.solver import number_of_symbols from phcpy.interface import store_quaddobl_system, load_quaddobl_system from phcpy.phcpy2c3 import py2c_quaddobl_Newton_power_series as newton from phcpy.phcpy2c3 import py2c_syspool_quaddobl_init from phcpy.phcpy2c3 import py2c_syspool_quaddobl_create from phcpy.phcpy2c3 import py2c_syspool_quaddobl_size as poolsize from phcpy.phcpy2c3 import py2c_syspool_copy_to_quaddobl_container from phcpy.phcpy2c3 import py2c_syspool_quaddobl_clear nbsym = number_of_symbols(pols) if verbose: print("the polynomials :") for pol in pols: print(pol) print("Number of variables :", nbsym) store_quaddobl_system(lser, nbvar=1) py2c_syspool_quaddobl_init(1) py2c_syspool_quaddobl_create(1) store_quaddobl_system(pols, nbvar=nbsym) fail = newton(idx, nbr, int(verbose)) size = (-1 if fail else poolsize()) if verbose: if size == -1: print("An error occurred in the execution of Newton's method.") else: print("Computed one series solution.") py2c_syspool_copy_to_quaddobl_container(1) result = load_quaddobl_system() result = substitute_symbol(result, idx) py2c_syspool_quaddobl_clear() return result
def quaddobl_newton_power_series(pols, lser, idx=1, nbr=4, verbose=True): r""" Computes series in quad double precision for the polynomials in *pols*, where the leading terms are given in the list *lser*. On entry are the following five parameters: *pols*: a list of string representations of polynomials, *lser*: a list of polynomials in the series parameter (e.g.: t), for use as start terms in Newton's method, *idx*: index of the series parameter, by default equals 1, *nbr*: number of steps with Newton's method, *verbose*: whether to write intermediate output to screen or not. On return is a list of lists of strings. Each lists of strings represents the series solution for the variables in the list *pols*. """ from phcpy.solver import number_of_symbols from phcpy.interface import store_quaddobl_system, load_quaddobl_system from phcpy.phcpy2c2 import py2c_quaddobl_Newton_power_series as newton from phcpy.phcpy2c2 import py2c_syspool_quaddobl_init from phcpy.phcpy2c2 import py2c_syspool_quaddobl_create from phcpy.phcpy2c2 import py2c_syspool_quaddobl_size as poolsize from phcpy.phcpy2c2 import py2c_syspool_copy_to_quaddobl_container from phcpy.phcpy2c2 import py2c_syspool_quaddobl_clear nbsym = number_of_symbols(pols) if verbose: print "the polynomials :" for pol in pols: print pol print "Number of variables :", nbsym store_quaddobl_system(lser, nbvar=1) py2c_syspool_quaddobl_init(1); py2c_syspool_quaddobl_create(1); store_quaddobl_system(pols, nbvar=nbsym) fail = newton(idx, nbr, int(verbose)) size = (-1 if fail else poolsize()) if verbose: if size == -1: print "An error occurred in the execution of Newton's method." else: print "Computed one series solution." py2c_syspool_copy_to_quaddobl_container(1) result = load_quaddobl_system() result = substitute_symbol(result, idx) py2c_syspool_quaddobl_clear() return result
def dobldobl_newton_series(pols, sols, idx=1, maxdeg=4, nbr=4, verbose=True): r""" Computes series in double double precision for the polynomials in *pols*, where the leading coefficients are the solutions in *sols*. On entry are the following five parameters: *pols*: a list of string representations of polynomials, *sols*: a list of solutions of the polynomials in *pols*, *idx*: index of the series parameter, by default equals 1, *maxdeg*: maximal degree of the series, *nbr*: number of steps with Newton's method, *verbose*: whether to write intermediate output to screen or not. On return is a list of lists of strings. Each lists of strings represents the series solution for the variables in the list *pols*. """ from phcpy.solver import number_of_symbols from phcpy.interface import store_dobldobl_solutions from phcpy.interface import store_dobldobl_system, load_dobldobl_system from phcpy.phcpy2c2 import py2c_dobldobl_Newton_series as newton from phcpy.phcpy2c2 import py2c_syspool_dobldobl_size as poolsize from phcpy.phcpy2c2 import py2c_syspool_copy_to_dobldobl_container from phcpy.phcpy2c2 import py2c_syspool_dobldobl_clear nbsym = number_of_symbols(pols) if verbose: print "the polynomials :" for pol in pols: print pol print "Number of variables :", nbsym store_dobldobl_system(pols, nbvar=nbsym) store_dobldobl_solutions(nbsym, sols) fail = newton(idx, maxdeg, nbr, int(verbose)) size = (-1 if fail else poolsize()) if verbose: if size == -1: print "An error occurred in the execution of Newton's method." else: print "Computed %d series solutions." % size result = [] for k in range(1, size+1): py2c_syspool_copy_to_dobldobl_container(k) sersol = load_dobldobl_system() result.append(substitute_symbol(sersol, idx)) py2c_syspool_dobldobl_clear() return result
def dobldobl_newton_series(pols, sols, idx=1, nbr=4, verbose=True): r""" Computes series in double double precision for the polynomials in *pols*, where the leading coefficients are the solutions in *sols*. On entry are the following five parameters: *pols*: a list of string representations of polynomials, *sols*: a list of solutions of the polynomials in *pols*, *idx*: index of the series parameter, by default equals 1, *nbr*: number of steps with Newton's method, *verbose*: whether to write intermediate output to screen or not. On return is a list of lists of strings. Each lists of strings represents the series solution for the variables in the list *pols*. """ from phcpy.solver import number_of_symbols from phcpy.interface import store_dobldobl_solutions from phcpy.interface import store_dobldobl_system, load_dobldobl_system from phcpy.phcpy2c2 import py2c_dobldobl_Newton_series as newton from phcpy.phcpy2c2 import py2c_syspool_dobldobl_size as poolsize from phcpy.phcpy2c2 import py2c_syspool_copy_to_dobldobl_container from phcpy.phcpy2c2 import py2c_syspool_dobldobl_clear nbsym = number_of_symbols(pols) if verbose: print "the polynomials :" for pol in pols: print pol print "Number of variables :", nbsym store_dobldobl_system(pols, nbvar=nbsym) store_dobldobl_solutions(nbsym, sols) fail = newton(idx, nbr, int(verbose)) size = (-1 if fail else poolsize()) if verbose: if size == -1: print "An error occurred in the execution of Newton's method." else: print "Computed %d series solutions." % size result = [] for k in range(1, size+1): py2c_syspool_copy_to_dobldobl_container(k) sersol = load_dobldobl_system() result.append(substitute_symbol(sersol, idx)) py2c_syspool_dobldobl_clear() return result
def double_double_track(target, start, sols, gamma=0, tasks=0): r""" Does path tracking in double 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. The number of tasks in the multithreading is defined by *tasks*. The default zero value for *tasks* indicates no multithreading. On return are the string representations of the solutions computed at the end of the paths. """ from phcpy.phcpy2c3 import py2c_copy_dobldobl_container_to_target_system from phcpy.phcpy2c3 import py2c_copy_dobldobl_container_to_start_system from phcpy.phcpy2c3 import py2c_copy_dobldobl_container_to_start_solutions from phcpy.phcpy2c3 import py2c_create_dobldobl_homotopy from phcpy.phcpy2c3 import py2c_create_dobldobl_homotopy_with_gamma from phcpy.phcpy2c3 import py2c_solve_by_dobldobl_homotopy_continuation from phcpy.phcpy2c3 import py2c_solcon_clear_dobldobl_solutions from phcpy.phcpy2c3 import py2c_copy_dobldobl_target_solutions_to_container from phcpy.interface import store_dobldobl_system from phcpy.interface import store_dobldobl_solutions from phcpy.interface import load_dobldobl_solutions from phcpy.solver import number_of_symbols dim = number_of_symbols(start) store_dobldobl_system(target, nbvar=dim) py2c_copy_dobldobl_container_to_target_system() store_dobldobl_system(start, nbvar=dim) py2c_copy_dobldobl_container_to_start_system() # py2c_clear_dobldobl_homotopy() if(gamma == 0): py2c_create_dobldobl_homotopy() else: py2c_create_dobldobl_homotopy_with_gamma(gamma.real, gamma.imag) # dim = len(start) store_dobldobl_solutions(dim, sols) py2c_copy_dobldobl_container_to_start_solutions() py2c_solve_by_dobldobl_homotopy_continuation(tasks) py2c_solcon_clear_dobldobl_solutions() py2c_copy_dobldobl_target_solutions_to_container() return load_dobldobl_solutions()
def quaddobl_set_homotopy(target, start, verbose=False): """ Initializes the homotopy with the target and start system for a step-by-step run of the series-Pade tracker, in quad double precision. If verbose, then extra output is written. Returns the failure code of the homotopy initializer. """ from phcpy.phcpy2c3 import py2c_copy_quaddobl_container_to_target_system from phcpy.phcpy2c3 import py2c_copy_quaddobl_container_to_start_system from phcpy.interface import store_quaddobl_system 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() from phcpy.phcpy2c3 import py2c_padcon_quaddobl_initialize_homotopy return py2c_padcon_quaddobl_initialize_homotopy(int(verbose))
def run_tracker(start, sols, target, sol_num, gamma, min_step, max_step, num_steps): set_homotopy_continuation_gamma(gamma.real, gamma.imag) set_homotopy_continuation_parameter(5, min_step) set_homotopy_continuation_parameter(4, max_step) set_homotopy_continuation_parameter(12, num_steps) dim = number_of_symbols(start) result = [[], [], [], [], [], [], []] for i in range(dim): result[2].append([]) standard_set_homotopy(target, start, False) idx = 0 choice_sol = sol_num solution = sols[choice_sol - 1] idx = idx + 1 standard_set_solution(dim, solution, False) solution = standard_get_solution(False) solution_dict = strsol2dict(solution) var_names = variables(solution_dict) var_names.sort() result[0].append(standard_t_value()) result[1].append(standard_step_size()) for i in range(len(var_names)): result[2][i].append(solution_dict[var_names[i]]) result[3].append(standard_closest_pole()) result[4].append(standard_pole_radius()) result[5].append(standard_series_coefficients(dim)) result[6].append(standard_pade_vector(dim)) for i in range(num_steps): standard_predict_correct(False) solution = standard_get_solution(False) solution_dict = strsol2dict(solution) result[0].append(standard_t_value()) result[1].append(standard_step_size()) for j in range(len(var_names)): result[2][j].append(solution_dict[var_names[j]]) result[3].append(standard_closest_pole()) result[4].append(standard_pole_radius()) result[5].append(standard_series_coefficients(dim)) result[6].append(standard_pade_vector(dim)) for i in range(len(result[2])): for j in range(len(result[2][i])): result[2][i][j] = (result[2][i][j].real, result[2][i][j].imag) return result
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 double_double_track(target, start, sols, gamma=0, tasks=0): """ Does path tracking in double 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.phcpy2c3 import py2c_copy_dobldobl_container_to_target_system from phcpy.phcpy2c3 import py2c_copy_dobldobl_container_to_start_system from phcpy.phcpy2c3 import py2c_copy_dobldobl_container_to_start_solutions from phcpy.phcpy2c3 import py2c_create_dobldobl_homotopy from phcpy.phcpy2c3 import py2c_create_dobldobl_homotopy_with_gamma from phcpy.phcpy2c3 import py2c_solve_by_dobldobl_homotopy_continuation from phcpy.phcpy2c3 import py2c_solcon_clear_dobldobl_solutions from phcpy.phcpy2c3 import py2c_copy_dobldobl_target_solutions_to_container from phcpy.interface import store_dobldobl_system from phcpy.interface import store_dobldobl_solutions from phcpy.interface import load_dobldobl_solutions from phcpy.solver import number_of_symbols dim = number_of_symbols(start) store_dobldobl_system(target, nbvar=dim) py2c_copy_dobldobl_container_to_target_system() store_dobldobl_system(start, nbvar=dim) py2c_copy_dobldobl_container_to_start_system() # py2c_clear_dobldobl_homotopy() if (gamma == 0): py2c_create_dobldobl_homotopy() else: py2c_create_dobldobl_homotopy_with_gamma(gamma.real, gamma.imag) # dim = len(start) store_dobldobl_solutions(dim, sols) py2c_copy_dobldobl_container_to_start_solutions() py2c_solve_by_dobldobl_homotopy_continuation(tasks) py2c_solcon_clear_dobldobl_solutions() py2c_copy_dobldobl_target_solutions_to_container() return load_dobldobl_solutions()
def quaddobl_set_parameter_homotopy(hom, idx, verbose=False): """ Initializes the homotopy with the polynomials in hom for a step-by-step run of the series-Pade tracker, in quad double precision. The value idx gives the index of the continuation parameter and is the index of one of the variables in the homotopy hom. If verbose, then extra output is written. Returns the failure code of the homotopy initializer. """ from phcpy.phcpy2c3 import py2c_copy_quaddobl_container_to_target_system from phcpy.interface import store_quaddobl_system from phcpy.solver import number_of_symbols dim = number_of_symbols(hom) store_quaddobl_system(hom, nbvar=dim) py2c_copy_quaddobl_container_to_target_system() from phcpy.phcpy2c3 \ import py2c_padcon_quaddobl_initialize_parameter_homotopy vrb = int(verbose) return py2c_padcon_quaddobl_initialize_parameter_homotopy(idx, vrb)
def quaddobl_next_track(target, start, sols, verbose=False): """ Runs the series-Pade tracker step by step in quad double precision. On input are a target system and a start system with solutions. 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. The function is interactive, prompting the user each time before performing the next predictor-corrector step. If verbose, then extra output is written. On return are the string representations of the solutions computed at the end of the paths. """ from phcpy.solver import number_of_symbols result = [] dim = number_of_symbols(start) quaddobl_set_homotopy(target, start, verbose) idx = 0 for sol in sols: idx = idx + 1 quaddobl_set_solution(dim, sol, verbose) while (True): answer = input('next predictor-corrector step ? (y/n) ') if (answer != 'y'): result.append(sol) break else: quaddobl_predict_correct(verbose) sol = quaddobl_get_solution(verbose) print(sol) (tval, step) = (quaddobl_t_value(), quaddobl_step_size()) frp = quaddobl_pole_radius() print("t : %.3e, step : %.3e, frp : %.3e" % (tval, step, frp)) cfp = quaddobl_closest_pole() print("closest pole : ", cfp) print('the series:', quaddobl_series_coefficients(dim)) print('Pade vector:', quaddobl_pade_vector(dim)) print('poles:', quaddobl_poles(dim)) return result
def quaddobl_track(target, start, sols, filename="", verbose=False): """ Wraps the tracker for Pade continuation in quad double precision. On input are a target system, a start system with solutions, optionally: a string *filename* and the *verbose* flag. 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. 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_with_gamma from phcpy.phcpy2c2 import py2c_clear_quaddobl_homotopy from phcpy.phcpy2c2 import py2c_clear_quaddobl_operations_data 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 from phcpy.phcpy2c2 import py2c_padcon_quaddobl_track 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() (regamma, imgamma) = get_homotopy_continuation_parameter(1) store_quaddobl_solutions(dim, sols) py2c_copy_quaddobl_container_to_start_solutions() (regamma, imgamma) = get_homotopy_continuation_parameter(1) py2c_create_quaddobl_homotopy_with_gamma(regamma, imgamma) nbc = len(filename) fail = py2c_padcon_quaddobl_track(nbc, filename, int(verbose)) # py2c_clear_quaddobl_homotopy() # py2c_clear_quaddobl_operations_data() return load_quaddobl_solutions()
def quaddobl_newton_power_series(pols, lser, idx=1, maxdeg=4, nbr=4, \ checkin=True, verbose=True): r""" Computes series in quad double precision for the polynomials in *pols*, where the leading terms are given in the list *lser*. On entry are the following five parameters: *pols*: a list of string representations of polynomials, *lser*: a list of polynomials in the series parameter (e.g.: t), for use as start terms in Newton's method, *idx*: index of the series parameter, by default equals 1, *maxdeg*: maximal degree of the series, *nbr*: number of steps with Newton's method, *checkin*: checks whether the number of symbols in pols matches the length of the list lser if idx == 0, or is one less than the length of the list lser if idx != 0. If the conditions are not satisfied, then an error message is printed and lser is returned. *verbose*: whether to write intermediate output to screen or not. On return is a list of lists of strings. Each lists of strings represents the series solution for the variables in the list *pols*. """ from phcpy.solver import number_of_symbols from phcpy.interface import store_quaddobl_system, load_quaddobl_system from phcpy.phcpy2c2 import py2c_quaddobl_Newton_power_series as newton from phcpy.phcpy2c2 import py2c_syspool_quaddobl_init from phcpy.phcpy2c2 import py2c_syspool_quaddobl_create from phcpy.phcpy2c2 import py2c_syspool_quaddobl_size as poolsize from phcpy.phcpy2c2 import py2c_syspool_copy_to_quaddobl_container from phcpy.phcpy2c2 import py2c_syspool_quaddobl_clear nbsym = number_of_symbols(pols) if verbose: print "the polynomials :" for pol in pols: print pol print "Number of variables :", nbsym if checkin: if not checkin_newton_power_series(nbsym, lser, idx): return lser store_quaddobl_system(lser, nbvar=1) py2c_syspool_quaddobl_init(1); py2c_syspool_quaddobl_create(1); store_quaddobl_system(pols, nbvar=nbsym) fail = newton(idx, maxdeg, nbr, int(verbose)) size = (-1 if fail else poolsize()) if verbose: if size == -1: print "An error occurred in the execution of Newton's method." else: print "Computed one series solution." py2c_syspool_copy_to_quaddobl_container(1) result = load_quaddobl_system() result = substitute_symbol(result, idx) py2c_syspool_quaddobl_clear() return result