def multprec_usolve(pol, mxi, eps, decimals): """ Applies the method of Durand-Kerner (aka Weierstrass) to the polynomial in the string pol, in arbitrary multiprecision, the number of decimal places in the precision is in decimals. The maximum number of iterations is in mxi, the requirement on the accuracy in eps. """ from phcpy.phcpy2c2 import py2c_usolve_multprec from phcpy.interface import store_multprec_system, load_multprec_solutions store_multprec_system([pol], decimals) nit = py2c_usolve_multprec(decimals, mxi, eps) rts = load_multprec_solutions() return (nit, rts)
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 interface import store_standard_laurent_system from interface import store_standard_solutions, load_standard_solutions store_standard_laurent_system(system) store_standard_solutions(len(system), solutions) from phcpy.phcpy2c2 import py2c_standard_Newton_Laurent_step py2c_standard_Newton_Laurent_step() result = load_standard_solutions() elif(precision == 'dd'): from interface import store_dobldobl_laurent_system from interface import store_dobldobl_solutions, load_dobldobl_solutions store_dobldobl_laurent_system(system) store_dobldobl_solutions(len(system), solutions) from phcpy.phcpy2c2 import py2c_dobldobl_Newton_Laurent_step py2c_dobldobl_Newton_Laurent_step() result = load_dobldobl_solutions() elif(precision == 'qd'): from interface import store_quaddobl_laurent_system from interface import store_quaddobl_solutions, load_quaddobl_solutions store_quaddobl_laurent_system(system) store_quaddobl_solutions(len(system), solutions) from phcpy.phcpy2c2 import py2c_quaddobl_Newton_Laurent_step py2c_quaddobl_Newton_Laurent_step() result = load_quaddobl_solutions() elif(precision == 'mp'): from interface import store_multprec_laurent_system from interface import store_multprec_solutions, load_multprec_solutions store_multprec_laurent_system(system, decimals) store_multprec_solutions(len(system), solutions) from phcpy.phcpy2c2 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 newton_steps(system, solutions, accuracy=8, maxsteps=4, maxprec=256): """ Runs a sequence of variable precision Newton steps to approximate solutions accurate up to a specified number of decimal places. In addition to the system and solutions, there are three parameters: accuracy : number of decimal places wanted to be accurate, maxsteps : maximum number of Newton steps, maxprec : maximum number of decimal places in the precision used to estimate the condition numbers. """ from phcpy.phcpy2c2 import py2c_varbprec_Newton_Laurent_steps as vmpnewt from phcpy.interface import store_multprec_solutions from phcpy.interface import load_multprec_solutions dim = len(system) store_multprec_solutions(dim, solutions) pols = "" for polynomial in system: pols = pols + polynomial vmpnewt(dim, accuracy, maxsteps, maxprec, len(pols), pols) result = load_multprec_solutions() return result