def dobldobl_pade_approximants(pols, sols, idx=1, numdeg=2, dendeg=2, \ nbr=4, verbose=True): r""" Computes Pade approximants based on the series in double 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_dobldobl_solutions from phcpy.interface import store_dobldobl_system, load_dobldobl_system from phcpy.phcpy2c3 \ import py2c_dobldobl_Pade_approximant as Pade_approximants from phcpy.phcpy2c3 import py2c_syspool_dobldobl_size as poolsize from phcpy.phcpy2c3 import py2c_syspool_copy_to_dobldobl_container from phcpy.phcpy2c3 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 = 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_dobldobl_container(k) sersol = load_dobldobl_system() substsersol = substitute_symbol(sersol, idx) result.append(make_fractions(substsersol)) py2c_syspool_dobldobl_clear() return result
def initialize_dobldobl_solution(nvar, sol): r""" A double double precision path tracker with a generator is initialized with a start solution *sol* in a number of variables equal to the value of *nvar*. """ from phcpy.phcpy2c3 import py2c_initialize_dobldobl_solution from phcpy.interface import store_dobldobl_solutions store_dobldobl_solutions(nvar, [sol]) return py2c_initialize_dobldobl_solution(1)
def initialize_dobldobl_solution(nvar, sol): """ A double double precision path tracker with a generator is initialized with a start solution sol in a number of variables equal to the value of nvar. """ from phcpy.phcpy2c2 import py2c_initialize_dobldobl_solution from phcpy.interface import store_dobldobl_solutions store_dobldobl_solutions(nvar, [sol]) return py2c_initialize_dobldobl_solution(1)
def newton_laurent_step(system, solutions, precision='d', decimals=100): """ Applies one Newton step to the solutions of the Laurent system. For each solution, prints its last line of diagnostics. Four levels of precision are supported: d : standard double precision (1.1e-15 or 2^(-53)), dd : double double precision (4.9e-32 or 2^(-104)), qd : quad double precision (1.2e-63 or 2^(-209)). mp : arbitrary precision, where the number of decimal places in the working precision is determined by decimals. """ dim = number_of_symbols(system) if (precision == 'd'): from phcpy.interface import store_standard_laurent_system from phcpy.interface import store_standard_solutions from phcpy.interface import load_standard_solutions store_standard_laurent_system(system, nbvar=dim) store_standard_solutions(dim, solutions) from phcpy.phcpy2c3 import py2c_standard_Newton_Laurent_step py2c_standard_Newton_Laurent_step() result = load_standard_solutions() elif (precision == 'dd'): from phcpy.interface import store_dobldobl_laurent_system from phcpy.interface import store_dobldobl_solutions from phcpy.interface import load_dobldobl_solutions store_dobldobl_laurent_system(system, nbvar=dim) store_dobldobl_solutions(dim, solutions) from phcpy.phcpy2c3 import py2c_dobldobl_Newton_Laurent_step py2c_dobldobl_Newton_Laurent_step() result = load_dobldobl_solutions() elif (precision == 'qd'): from phcpy.interface import store_quaddobl_laurent_system from phcpy.interface import store_quaddobl_solutions from phcpy.interface import load_quaddobl_solutions store_quaddobl_laurent_system(system, nbvar=dim) store_quaddobl_solutions(dim, solutions) from phcpy.phcpy2c3 import py2c_quaddobl_Newton_Laurent_step py2c_quaddobl_Newton_Laurent_step() result = load_quaddobl_solutions() elif (precision == 'mp'): from phcpy.interface import store_multprec_laurent_system from phcpy.interface import store_multprec_solutions from phcpy.interface import load_multprec_solutions store_multprec_laurent_system(system, decimals, nbvar=dim) store_multprec_solutions(dim, solutions) from phcpy.phcpy2c3 import py2c_multprec_Newton_Laurent_step py2c_multprec_Newton_Laurent_step(decimals) result = load_multprec_solutions() else: print('wrong argument for precision') return None for sol in result: strsol = sol.split('\n') print(strsol[-1]) return result
def dobldobl_set_solution(nvar, sol, verbose=False): r""" Sets the start solution in *sol* for the step-by-step run of the series-Pade tracker, in double double precision. If verbose, then extra output is written. The number of variables is in *nvar*. """ from phcpy.phcpy2c3 import py2c_padcon_initialize_dobldobl_solution from phcpy.interface import store_dobldobl_solutions store_dobldobl_solutions(nvar, [sol]) return py2c_padcon_initialize_dobldobl_solution(1, int(verbose))
def newton_laurent_step(system, solutions, precision='d', decimals=100): """ Applies one Newton step to the solutions of the Laurent system. For each solution, prints its last line of diagnostics. Four levels of precision are supported: d : standard double precision (1.1e-15 or 2^(-53)), dd : double double precision (4.9e-32 or 2^(-104)), qd : quad double precision (1.2e-63 or 2^(-209)). mp : arbitrary precision, where the number of decimal places in the working precision is determined by decimals. """ if(precision == 'd'): from phcpy.interface import store_standard_laurent_system from phcpy.interface import store_standard_solutions from phcpy.interface import load_standard_solutions store_standard_laurent_system(system) store_standard_solutions(len(system), solutions) from phcpy.phcpy2c3 import py2c_standard_Newton_Laurent_step py2c_standard_Newton_Laurent_step() result = load_standard_solutions() elif(precision == 'dd'): from phcpy.interface import store_dobldobl_laurent_system from phcpy.interface import store_dobldobl_solutions from phcpy.interface import load_dobldobl_solutions store_dobldobl_laurent_system(system) store_dobldobl_solutions(len(system), solutions) from phcpy.phcpy2c3 import py2c_dobldobl_Newton_Laurent_step py2c_dobldobl_Newton_Laurent_step() result = load_dobldobl_solutions() elif(precision == 'qd'): from phcpy.interface import store_quaddobl_laurent_system from phcpy.interface import store_quaddobl_solutions from phcpy.interface import load_quaddobl_solutions store_quaddobl_laurent_system(system) store_quaddobl_solutions(len(system), solutions) from phcpy.phcpy2c3 import py2c_quaddobl_Newton_Laurent_step py2c_quaddobl_Newton_Laurent_step() result = load_quaddobl_solutions() elif(precision == 'mp'): from phcpy.interface import store_multprec_laurent_system from phcpy.interface import store_multprec_solutions from phcpy.interface import load_multprec_solutions store_multprec_laurent_system(system, decimals) store_multprec_solutions(len(system), solutions) from phcpy.phcpy2c3 import py2c_multprec_Newton_Laurent_step py2c_multprec_Newton_Laurent_step(decimals) result = load_multprec_solutions() else: print('wrong argument for precision') return None for sol in result: strsol = sol.split('\n') print(strsol[-1]) 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_scale_solutions(nvar, sols, cffs): """ Scales the solutions in the list sols using the coefficients in cffs, using double double precision arithmetic. The number of variables is given in the parameter nvar. If the sols are the solution of the polynomials in the output of dobldobl_scale_system(pols), then the solutions on return will be solutions of the original polynomials in the list pols. """ from phcpy.interface import store_dobldobl_solutions from phcpy.interface import load_dobldobl_solutions from phcpy.phcpy2c3 import py2c_scale_dobldobl_solutions store_dobldobl_solutions(nvar, sols) py2c_scale_dobldobl_solutions(len(cffs), str(cffs)) return load_dobldobl_solutions()
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 ade_tuned_double_double_track\ (target, start, sols, pars, gamma=0, verbose=1): r""" Does path tracking with algorithm differentiation, in double double precision, with tuned path parameters. On input are a target system, 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 *pars* is a tuple of 14 values for the path parameters. On return are the string representations of the solutions computed at the end of the paths. If *gamma* on input equals zero, then a random complex number is generated, otherwise the real and imaginary parts of *gamma* are used. """ 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_ade_manypaths_dd_pars from phcpy.interface import store_dobldobl_system from phcpy.interface import store_dobldobl_solutions from phcpy.interface import load_dobldobl_solutions store_dobldobl_system(target) py2c_copy_dobldobl_container_to_target_system() store_dobldobl_system(start) py2c_copy_dobldobl_container_to_start_system() dim = len(start) store_dobldobl_solutions(dim, sols) if(gamma == 0): from random import uniform from cmath import exp, pi angle = uniform(0, 2*pi) gamma = exp(angle*complex(0, 1)) if(verbose > 0): print('random gamma constant :', gamma) if(verbose > 0): print('the path parameters :\n', pars) fail = py2c_ade_manypaths_dd_pars(verbose, gamma.real, gamma.imag, \ pars[0], pars[1], pars[2], pars[3], pars[4], pars[5], pars[6], \ pars[7], pars[8], pars[9], pars[10], pars[11], pars[12], pars[13]) if(fail == 0): if(verbose > 0): print('Path tracking with AD was a success!') else: print('Path tracking with AD failed!') return load_dobldobl_solutions()
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 dobldobl_deflate(system, solutions): """ The deflation method augments the given system with derivatives to restore the quadratic convergence of Newton's method at isolated singular solutions, in double double precision. After application of deflation with default settings, the new approximate solutions are returned. """ from phcpy.phcpy2c3 import py2c_dobldobl_deflate from phcpy.interface import store_dobldobl_system from phcpy.interface import store_dobldobl_solutions from phcpy.interface import load_dobldobl_solutions store_dobldobl_system(system) store_dobldobl_solutions(len(system), solutions) py2c_dobldobl_deflate() result = load_dobldobl_solutions() return result
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 dobldobl_deflate(system, solutions): """ The deflation method augments the given system with derivatives to restore the quadratic convergence of Newton's method at isolated singular solutions, in double double precision. After application of deflation with default settings, the new approximate solutions are returned. """ from phcpy.phcpy2c3 import py2c_dobldobl_deflate from phcpy.interface import store_dobldobl_system from phcpy.interface import store_dobldobl_solutions from phcpy.interface import load_dobldobl_solutions dim = number_of_symbols(system) store_dobldobl_system(system, nbvar=dim) store_dobldobl_solutions(dim, solutions) py2c_dobldobl_deflate() result = load_dobldobl_solutions() return result
def gpu_double_double_track(target, start, sols, gamma=0, verbose=1): """ GPU accelerated path tracking with algorithm differentiation, in double double precision. On input are a target system, 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. On return are the string representations of the solutions computed at the end of the paths. If gamma on input equals zero, then a random complex number is generated, otherwise the real and imaginary parts of gamma are used. """ from phcpy.phcpy2c2 import py2c_copy_dobldobl_container_to_target_system from phcpy.phcpy2c2 import py2c_copy_dobldobl_container_to_start_system from phcpy.phcpy2c2 import py2c_gpu_manypaths_dd from phcpy.interface import store_dobldobl_system from phcpy.interface import store_dobldobl_solutions from phcpy.interface import load_dobldobl_solutions store_dobldobl_system(target) py2c_copy_dobldobl_container_to_target_system() store_dobldobl_system(start) py2c_copy_dobldobl_container_to_start_system() dim = len(start) store_dobldobl_solutions(dim, sols) if gamma == 0: from random import uniform from cmath import exp, pi angle = uniform(0, 2 * pi) gamma = exp(angle * complex(0, 1)) if verbose > 0: print "random gamma constant :", gamma fail = py2c_gpu_manypaths_dd(2, verbose, gamma.real, gamma.imag) if fail == 0: if verbose > 0: print "Path tracking on the GPU was a success!" else: print "Path tracking on the GPU failed!" return load_dobldobl_solutions()
def gpu_double_double_track(target, start, sols, gamma=0, verbose=1): """ GPU accelerated path tracking with algorithm differentiation, in double double precision. On input are a target system, 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. On return are the string representations of the solutions computed at the end of the paths. If gamma on input equals zero, then a random complex number is generated, otherwise the real and imaginary parts of gamma are used. """ from phcpy.phcpy2c2 import py2c_copy_dobldobl_container_to_target_system from phcpy.phcpy2c2 import py2c_copy_dobldobl_container_to_start_system from phcpy.phcpy2c2 import py2c_gpu_manypaths_dd from phcpy.interface import store_dobldobl_system from phcpy.interface import store_dobldobl_solutions from phcpy.interface import load_dobldobl_solutions store_dobldobl_system(target) py2c_copy_dobldobl_container_to_target_system() store_dobldobl_system(start) py2c_copy_dobldobl_container_to_start_system() dim = len(start) store_dobldobl_solutions(dim, sols) if(gamma == 0): from random import uniform from cmath import exp, pi angle = uniform(0, 2*pi) gamma = exp(angle*complex(0, 1)) if(verbose > 0): print 'random gamma constant :', gamma fail = py2c_gpu_manypaths_dd(2, verbose, gamma.real, gamma.imag) if(fail == 0): if(verbose > 0): print 'Path tracking on the GPU was a success!' else: print 'Path tracking on the GPU failed!' return load_dobldobl_solutions()
def dobldobl_track(target, start, sols, filename="", verbose=False): """ Wraps the tracker for Pade continuation in double 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_dobldobl_container_to_target_system from phcpy.phcpy2c2 import py2c_copy_dobldobl_container_to_start_system from phcpy.phcpy2c2 import py2c_copy_dobldobl_container_to_start_solutions from phcpy.phcpy2c2 import py2c_create_dobldobl_homotopy_with_gamma from phcpy.phcpy2c2 import py2c_clear_dobldobl_homotopy from phcpy.phcpy2c2 import py2c_clear_dobldobl_operations_data 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 from phcpy.phcpy2c2 import py2c_padcon_dobldobl_track 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() (regamma, imgamma) = get_homotopy_continuation_parameter(1) store_dobldobl_solutions(dim, sols) py2c_copy_dobldobl_container_to_start_solutions() nbc = len(filename) (regamma, imgamma) = get_homotopy_continuation_parameter(1) py2c_create_dobldobl_homotopy_with_gamma(regamma, imgamma) fail = py2c_padcon_dobldobl_track(nbc, filename, int(verbose)) # py2c_clear_dobldobl_homotopy() # py2c_clear_dobldobl_operations_data() return load_dobldobl_solutions()