def test_monitored_track(): """ Often the number of paths to track can be huge and waiting on the outcome of track() without knowing how many paths that have been tracked so far can be annoying. This script illustrates how one can monitor the progress of the path tracking. We must use the same gamma constant with each call of track. """ from random import uniform from cmath import pi, exp angle = uniform(0, 2 * pi) ourgamma = exp(complex(0, 1) * angle) from phcpy.solver import total_degree_start_system, newton_step quadrics = ["x**2 + 4*y**2 - 4;", "2*y**2 - x;"] (startsys, startsols) = total_degree_start_system(quadrics) targetsols = [] for ind in range(0, len(startsols)): print "tracking path", ind + 1, "...", endsol = track(quadrics, startsys, [startsols[ind]], gamma=ourgamma) print "found solution\n", endsol[0] targetsols.append(endsol[0]) print "tracked", len(targetsols), "paths, running newton_step..." newton_step(quadrics, targetsols)
def _start_system(self): """ We first set up a start system so phcpy doesn't have to create a new one everytime. """ phcsystem = self._system() startsystem, startsol = total_degree_start_system(phcsystem) return startsystem, startsol
def test_next_track(precision="d", decimals=80): """ Tests the step-by-step tracking of a solution path. Three 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 multiprecision with as many decimal places in the working precision as the value set by decimals. """ from phcpy.solver import total_degree_start_system quadrics = ["x**2 + 4*y**2 - 4;", "2*y**2 - x;"] (startsys, startsols) = total_degree_start_system(quadrics) print "the first start solution :\n", startsols[0] if precision == "d": initialize_standard_tracker(quadrics, startsys) initialize_standard_solution(2, startsols[0]) while True: sol = next_standard_solution() print "the next solution :\n", sol answer = raw_input("continue ? (y/n) ") if answer != "y": break elif precision == "dd": initialize_dobldobl_tracker(quadrics, startsys) initialize_dobldobl_solution(2, startsols[0]) while True: sol = next_dobldobl_solution() print "the next solution :\n", sol answer = raw_input("continue ? (y/n) ") if answer != "y": break elif precision == "qd": initialize_quaddobl_tracker(quadrics, startsys) initialize_quaddobl_solution(2, startsols[0]) while True: sol = next_quaddobl_solution() print "the next solution :\n", sol answer = raw_input("continue ? (y/n) ") if answer != "y": break elif precision == "mp": initialize_multprec_tracker(quadrics, startsys, decimals) initialize_multprec_solution(2, startsols[0]) while True: sol = next_multprec_solution() print "the next solution :\n", sol answer = raw_input("continue ? (y/n) ") if answer != "y": break else: print "wrong argument for precision"
def test_next_track(precision='d', decimals=80): """ Tests the step-by-step tracking of a solution path. Three 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 multiprecision with as many decimal places in the working precision as the value set by decimals. """ from phcpy.solver import total_degree_start_system quadrics = ['x**2 + 4*y**2 - 4;', '2*y**2 - x;'] (startsys, startsols) = total_degree_start_system(quadrics) print 'the first start solution :\n', startsols[0] if(precision == 'd'): initialize_standard_tracker(quadrics, startsys) initialize_standard_solution(2, startsols[0]) while True: sol = next_standard_solution() print 'the next solution :\n', sol answer = raw_input('continue ? (y/n) ') if(answer != 'y'): break elif(precision == 'dd'): initialize_dobldobl_tracker(quadrics, startsys) initialize_dobldobl_solution(2, startsols[0]) while True: sol = next_dobldobl_solution() print 'the next solution :\n', sol answer = raw_input('continue ? (y/n) ') if(answer != 'y'): break elif(precision == 'qd'): initialize_quaddobl_tracker(quadrics, startsys) initialize_quaddobl_solution(2, startsols[0]) while True: sol = next_quaddobl_solution() print 'the next solution :\n', sol answer = raw_input('continue ? (y/n) ') if(answer != 'y'): break elif(precision == 'mp'): initialize_multprec_tracker(quadrics, startsys, decimals) initialize_multprec_solution(2, startsols[0]) while True: sol = next_multprec_solution() print 'the next solution :\n', sol answer = raw_input('continue ? (y/n) ') if(answer != 'y'): break else: print 'wrong argument for precision'
def test_next_track(precision='d', decimals=80): """ Tests the step-by-step tracking of a solution path. Three 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 multiprecision with as many decimal places in the working precision as the value set by decimals. """ from phcpy.solver import total_degree_start_system quadrics = ['x**2 + 4*y**2 - 4;', '2*y**2 - x;'] (startsys, startsols) = total_degree_start_system(quadrics) print('the first start solution :\n', startsols[0]) if(precision == 'd'): initialize_standard_tracker(quadrics, startsys) initialize_standard_solution(2, startsols[0]) while True: sol = next_standard_solution() print('the next solution :\n', sol) answer = input('continue ? (y/n) ') if(answer != 'y'): break elif(precision == 'dd'): initialize_dobldobl_tracker(quadrics, startsys) initialize_dobldobl_solution(2, startsols[0]) while True: sol = next_dobldobl_solution() print('the next solution :\n', sol) answer = input('continue ? (y/n) ') if(answer != 'y'): break elif(precision == 'qd'): initialize_quaddobl_tracker(quadrics, startsys) initialize_quaddobl_solution(2, startsols[0]) while True: sol = next_quaddobl_solution() print('the next solution :\n', sol) answer = input('continue ? (y/n) ') if(answer != 'y'): break elif(precision == 'mp'): initialize_multprec_tracker(quadrics, startsys, decimals) initialize_multprec_solution(2, startsols[0]) while True: sol = next_multprec_solution() print('the next solution :\n', sol) answer = input('continue ? (y/n) ') if(answer != 'y'): break else: print('wrong argument for precision')
def test_monitored_track(): """ Often the number of paths to track can be huge and waiting on the outcome of track() without knowing how many paths that have been tracked so far can be annoying. This script illustrates how one can monitor the progress of the path tracking. We must use the same gamma constant with each call of track. """ from random import uniform from cmath import pi, exp angle = uniform(0, 2*pi) ourgamma = exp(complex(0, 1)*angle) from phcpy.solver import total_degree_start_system, newton_step quadrics = ['x**2 + 4*y**2 - 4;', '2*y**2 - x;'] (startsys, startsols) = total_degree_start_system(quadrics) targetsols = [] for ind in range(0, len(startsols)): print 'tracking path', ind+1, '...', endsol = track(quadrics, startsys, [startsols[ind]], gamma=ourgamma) print 'found solution\n', endsol[0] targetsols.append(endsol[0]) print 'tracked', len(targetsols), 'paths, running newton_step...' newton_step(quadrics, targetsols)