Esempio n. 1
0
def main():
    """
    Excerpt from the user manual of phcpy.
    """
    from phcpy.phcpy2c3 import py2c_set_seed
    py2c_set_seed(2019)
    p = ['x^2 + y - 3;', 'x + 0.125*y^2 - 1.5;']
    print('constructing a total degree start system ...')
    from phcpy.solver import total_degree_start_system as tds
    q, qsols = tds(p)
    print('number of start solutions :', len(qsols))
    from phcpy.trackers import initialize_standard_tracker
    from phcpy.trackers import initialize_standard_solution
    from phcpy.trackers import next_standard_solution
    initialize_standard_tracker(p, q, False) # True)
    # initialize_standard_tracker(p, q, True)
    from phcpy.solutions import strsol2dict
    import matplotlib.pyplot as plt
    plt.ion()
    fig = plt.figure()
    for k in range(len(qsols)):
        if(k == 0):
            axs = fig.add_subplot(221)
        elif(k == 1):
            axs = fig.add_subplot(222)
        elif(k == 2):
            axs = fig.add_subplot(223)
        elif(k == 3):
            axs = fig.add_subplot(224)
        startsol = qsols[k]
        initialize_standard_solution(len(p),startsol)
        dictsol = strsol2dict(startsol)
        xpoints =  [dictsol['x']]
        ypoints =  [dictsol['y']]
        for k in range(300):
            ns = next_standard_solution()
            dictsol = strsol2dict(ns)
            xpoints.append(dictsol['x'])
            ypoints.append(dictsol['y'])
            tval = dictsol['t'].real
            # tval = eval(dictsol['t'].lstrip().split(' ')[0])
            if(tval == 1.0):
                break
        print(ns)
        xre = [point.real for point in xpoints]
        yre = [point.real for point in ypoints]
        axs.set_xlim(min(xre)-0.3, max(xre)+0.3)
        axs.set_ylim(min(yre)-0.3, max(yre)+0.3)
        dots, = axs.plot(xre,yre,'r-')
        fig.canvas.draw()
    fig.canvas.draw()
    ans = input('hit return to exit')
Esempio n. 2
0
def solve4circles(syst, verbose=True):
    """
    Given in syst is a list of polynomial systems.
    Returns a list of tuples.  Each tuple in the list of return
    consists of the coordinates of the center and the radius of
    a circle touching the three given circles.
    """
    from phcpy.solver import solve
    from phcpy.solutions import strsol2dict, is_real
    (circle, eqscnt) = (0, 0)
    result = []
    for eqs in syst:
        eqscnt = eqscnt + 1
        if verbose:
            print('solving system', eqscnt, ':')
            for pol in eqs:
                print(pol)
        sols = solve(eqs, silent=True)
        if verbose:
            print('system', eqscnt, 'has', len(sols), 'solutions')
        for sol in sols:
            if is_real(sol, 1.0e-8):
                soldic = strsol2dict(sol)
                if soldic['r'].real > 0:
                    circle = circle + 1
                    ctr = (soldic['x'].real, soldic['y'].real)
                    rad = soldic['r'].real
                    result.append((ctr, rad))
                    if verbose:
                        print('solution circle', circle)
                        print('center =', ctr)
                        print('radius =', rad)
    return result
Esempio n. 3
0
def straight_line(verbose=True):
    """
    This function solves an instance where the five precision
    points lie on a line.  The coordinates are taken from Problem 7
    of the paper by A.P. Morgan and C.W. Wampler.
    Returns a list of solution dictionaries for the real solutions.
    """
    from phcpy.solutions import strsol2dict, is_real
    pt0 = Matrix([[ 0.50], [ 1.06]])
    pt1 = Matrix([[-0.83], [-0.27]])
    pt2 = Matrix([[-0.34], [ 0.22]])
    pt3 = Matrix([[-0.13], [ 0.43]])
    pt4 = Matrix([[ 0.22], [ 0.78]])
    piv = Matrix([[1], [0]])
    equ = polynomials(pt0,pt1,pt2,pt3,pt4,piv)
    if verbose:
        print 'the polynomial system :'
        for pol in equ:
            print pol
    from phcpy.solver import solve
    sols = solve(equ)
    if verbose:
        print 'the solutions :'
        for sol in sols:
            print sol
        print 'computed', len(sols), 'solutions'
    result = []
    for sol in sols:
        if is_real(sol, 1.0e-8):
            soldic = strsol2dict(sol)
            result.append(soldic)
    return result
Esempio n. 4
0
def eqs(ip):

    #x1 -> omega_s
    #x2 -> ns
    #x3 -> np
       
    eq1 = "{0:+.16f}*x1{1:+.16f}*x2{2:+.16f}*x3{3:+.16f};"          .format((-gi - gs)/(gi*xs**2), -alpha**2 + 1, -2*alpha + 2, (-ei*gs + es*gi + 2*gs*omega_p_chosen)/(gi*xs**2))
    eq2 = "{0:.16f}*x1^2{1:+.16f}*x1*x2{2:+.16f}*x1*x3{3:+.16f}*x1{4:+.16f}*x2^2{5:+.16f}*x2*x3{6:+.16f}*x2{7:+.16f}*x3^2{8:+.16f}*x3{9:+.16f};"          .format(xs**(-4), (-4*alpha - 2)/xs**2, -4/xs**2, -2*es/xs**4, 4*alpha**2 + 4*alpha + 1, 8*alpha + 4, (4*alpha*es + 2*es)/xs**2, -alpha + 4, 4*es/xs**2, (4*es**2 + gs**2)/(4*xs**4))
    eq3 = "{0:.16f}*x1^2*x2^2{1:+.16f}*x1*x2^3{2:+.16f}*x1*x2^2*x3{3:+.16f}*x1*x2^2{4:+.16f}*x1*x2*x3^2{5:+.16f}*x1*x2*x3{6:+.16f}*x2^4{7:+.16f}*x2^3*x3{8:+.16f}*x2^3{9:+.16f}*x2^2*x3^2{10:+.16f}*x2^2*x3{11:+.16f}*x2^2{12:+.16f}*x2*x3^3{13:+.16f}*x2*x3^2{14:+.16f}*x2*x3{15:+.16f}*x3^4{16:+.16f}*x3^3{17:+.16f}*x3^2{18:+.16f}*x3;"          .format(4.0/xs**4, 1.0*(-16.0*alpha - 8.0)/xs**2, 1.0*(8.0*alpha - 8.0)/xs**2, -8.0*es/xs**4, 4.0/xs**2, 1.0*(4.0*ep - 4.0*omega_p_chosen)/(xp**2*xs**2), 16.0*alpha**2 + 16.0*alpha + 4.0, -16.0*alpha**2 + 8.0*alpha + 8.0, 1.0*(16.0*alpha*es + 8.0*es)/xs**2, 4.0*alpha**2 - 16.0*alpha, 1.0*(-8.0*alpha*ep*xs**2 - 8.0*alpha*es*xp**2 + 8.0*alpha*omega_p_chosen*xs**2 - 4.0*ep*xs**2 + 8.0*es*xp**2 + 4.0*omega_p_chosen*xs**2)/(xp**2*xs**2), 1.0*(4.0*es**2 + 1.0*gs**2)/xs**4, 4.0*alpha - 4.0, 1.0*(4.0*alpha*ep*xs**2 - 4.0*alpha*omega_p_chosen*xs**2 - 4.0*ep*xs**2 - 4.0*es*xp**2 + 4.0*omega_p_chosen*xs**2)/(xp**2*xs**2), 1.0*(-4.0*ep*es + 4.0*es*omega_p_chosen + 1.0*gs)/(xp**2*xs**2), 1.00000000000000, 1.0*(2.0*ep - 2.0*omega_p_chosen)/xp**2, 1.0*(1.0*ep**2 - 2.0*ep*omega_p_chosen + 1.0*omega_p_chosen**2 + 0.25)/xp**4, -1.0*ip)
    f = [eq1, eq2, eq3]
    
    #seeding random number generator for reproducible results
    py2c_set_seed(130683)
    
    s = solve(f,silent=True)
    ns = len(s) #number of solutions

    R = []
    for k in range(ns):
        d = strsol2dict(s[k])
        x123 = np.array([d['x1'], d['x2'], d['x3']])
        real = np.real(x123)
        imag = np.fabs(np.imag(x123))
        sol = np.empty((real.size + imag.size,), dtype=real.dtype)
        sol[0::2] = real
        sol[1::2] = imag
        if np.allclose(imag, np.zeros(3)):
            if real[1] > 1e-7:
                R.append((sol[0], sol[2], sol[4], ip))

    return R
Esempio n. 5
0
def phcpy(line, cell=None):
    "Solve a system of polynomials formatted for phcpy."
    # TODO: progress bar

    from phcpy.solver import solve
    from phcpy.solutions import strsol2dict

    if cell is None:
        with open(line, 'r') as poly:
            sys = ' '.join([f.rstrip() for f in poly])
    else:
        # jupyter uses unix newlines
        sys = ' '.join([f.rstrip() for f in cell.split('\n')]) 
                # cell.replace('\n',' ').lstrip()
        
    # discard equation count (and undeterminate count) if present
    while sys.split(' ')[0].isdigit():
        sys = sys.split(' ', 1)[1]
        
    # convert to list with delimiters intact
    sys = [f+';' for f in sys.split(';')[:-1]]
    # for l in sys: print(l)
        
    ret = solve(sys)
    return [strsol2dict(s) for s in ret]
def findEmbeddings_dist(syst,  interval):
    global prevSystem
    global usePrev
    global prevSolutions
#    i = 0
    y1_left,  y1_right, y4_left,  y4_right = interval
#    print fileNamePref
    while True:
        if prevSystem and usePrev:
            sols = track(syst, prevSystem, prevSolutions, tasks=tasks_num)
        else:
            sols = solve(syst, verbose=0, tasks=tasks_num)

        result_real = []
        for sol in sols:
            soldic = strsol2dict(sol)
            if is_real(sol, tolerance) and soldic['y1'].real>=y1_left and soldic['y1'].real<=y1_right and soldic['y4'].real>=y4_left and soldic['y4'].real<=y4_right:
                result_real.append(soldic)

        num_real = len(result_real)
        
        if num_real%2==0 and len(sols)==numAll:
            prevSystem = syst
            prevSolutions = sols
        return num_real
Esempio n. 7
0
def coordinates_and_slopes(sol):
    """
    Given a solution, return the 3-tuple with the x and y coordinates
    of the tangent point and the slope of the tangent line.
    The real parts of the coordinates are selected.
    """
    from phcpy.solutions import strsol2dict
    sdc = strsol2dict(sol)
    return (sdc['x'].real, sdc['y'].real, sdc['s'].real)
Esempio n. 8
0
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
Esempio n. 9
0
def verify(pols, sols):
    """
    Verifies whether the solutions in sols
    satisfy the polynomials of the system in pols.
    """
    from phcpy.solutions import strsol2dict, evaluate
    dictsols = [strsol2dict(sol) for sol in sols]
    checksum = 0
    for sol in dictsols:
        sumeval = sum(evaluate(pols, sol))
        print(sumeval)
        checksum = checksum + sumeval
    print('the total check sum :', checksum)
Esempio n. 10
0
def verify(pols, sols):
    """
    Verifies whether the solutions in sols
    satisfy the polynomials of the system in pols.
    """
    from phcpy.solutions import strsol2dict, evaluate
    dictsols = [strsol2dict(sol) for sol in sols]
    checksum = 0
    for sol in dictsols:
        sumeval = sum(evaluate(pols, sol))
        print(sumeval)
        checksum = checksum + sumeval
    print('the total check sum :', checksum)
Esempio n. 11
0
    def find_more_points(self, num_points, return_complex=False):
        """
        We find additional points on the variety.
        """
        points = []
        failure = 0
        while (len(points) < num_points):
            phcsystem = self._system()
            phcsolutions = track(phcsystem, self._startsystem, self._startsol)

            #  Parsing the output of solutions
            for sol in phcsolutions:
                solutiondict = strsol2dict(sol)

                point = [solutiondict[variable] for variable in self.varlist]
                if return_complex:
                    points.append(tuple(point))
                else:
                    closeness = True
                    for component in point:
                        # choses the points we want
                        if self._is_close(component.imag) \
                                and self._in_bounds(component.real):
                            # sometimes phcpy gives more points than we
                            # ask, thus the additional check
                            if component == point[-1] \
                                    and closeness \
                                    and len(points) < num_points:
                                points.append(
                                    tuple([
                                        component.real for component in point
                                    ]))
                                assert len(points) <= num_points
                                failure = 0
                        else:
                            closeness = False
                            failure = failure + 1
            if self._failure <= failure:
                raise RuntimeError(
                    "equation has too many complex solutions in a row")

        self.points = points + self.points
Esempio n. 12
0
def extend_solutions(sols, dim, pivots):
    """
    Adds one extra zero coordinate to all solutions in sols,
    corresponding to the rightmost nonfull pivot.
    """
    from phcpy.solutions import strsol2dict, variables, make_solution
    piv = rightmost_nonfull_pivot(dim, pivots)
    print '-> in extend_solutions, piv =', piv
    if (piv < 0):
        result = sols
    else:
        rown = pivots[piv] + 1  # row number of new variable
        name = 'x_' + str(rown + 1) + '_' + str(piv + 1)
        print '-> the name of the new variable :', name
        result = []
        for sol in sols:
            dicsol = strsol2dict(sol)
            solvar = variables(dicsol)
            solval = [dicsol[var] for var in solvar]
            solvar.append(name)
            solval.append(complex(0.0))
            result.append(make_solution(solvar, solval))
    return result
Esempio n. 13
0
def extend_solutions(sols, dim, pivots):
    """
    Adds one extra zero coordinate to all solutions in sols,
    corresponding to the rightmost nonfull pivot.
    """
    from phcpy.solutions import strsol2dict, variables, make_solution
    piv = rightmost_nonfull_pivot(dim, pivots)
    print '-> in extend_solutions, piv =', piv
    if(piv < 0):
        result = sols
    else:
        rown = pivots[piv] + 1  # row number of new variable 
        name = 'x_' + str(rown+1) + '_' + str(piv+1)
        print '-> the name of the new variable :', name
        result = []
        for sol in sols:
            dicsol = strsol2dict(sol)
            solvar = variables(dicsol)
            solval = [dicsol[var] for var in solvar] 
            solvar.append(name)
            solval.append(complex(0.0))
            result.append(make_solution(solvar, solval))
    return result
def findEmbeddings(syst):
    global prevSystem
    global usePrev
    global prevSolutions
    i = 0
    while True:
        if prevSystem and usePrev:
            sols = track(syst, prevSystem, prevSolutions, tasks=tasks_num)
        else:
            sols = solve(syst, verbose=0, tasks=tasks_num)

        result_real = []
        for sol in sols:
            soldic = strsol2dict(sol)
            if is_real(sol, tolerance):
                result_real.append(soldic)
        
        num_real = len(result_real)
        
        if num_real%4==0 and len(sols)==numAll:
            prevSystem = syst
            prevSolutions = sols
            return num_real
        elif numAllowedMissing and len(sols)==numAll:
            print 'The number of real embeddings was not divisible by 4. ', 
            return num_real
        elif numAllowedMissing and len(sols)>=numAll-numAllowedMissing:
            print 'Continuing although there were '+str(numAll-len(sols))+' solutions missing. ', 
            return num_real
        else:
            usePrev = False
            i += 1
#            print 'PHC failed, trying again: '+str(i)
        if i>=3:
            print 'PHC failed 3 times', 
            return -1
Esempio n. 15
0
"""
Get the x and y coordinates of a solution path.
First we take two quadrics and construct a start system
based on the total degree applying the theorem of Bezout.
To extract the coordinates of the points on a solution path,
we convert the string representation into a dictionary.
"""
f = ['x*y + y^2 - 8;', 'x^2 - 3*y + 4;']
print 'the polynomials in the target system :'
for pol in f:
    print pol
from phcpy.solver import total_degree_start_system as tds
(g, gsols) = tds(f)
print 'the polynomials in the start system :'
for pol in g:
    print pol
print 'number of start solutions :', len(gsols)
from phcpy.trackers import initialize_standard_tracker
from phcpy.trackers import initialize_standard_solution
from phcpy.trackers import next_standard_solution as nxtsol
initialize_standard_tracker(f, g)
initialize_standard_solution(len(g), gsols[0])
points = [nxtsol() for k in range(10)]
from phcpy.solutions import strsol2dict
dicpts = [strsol2dict(sol) for sol in points]
coords = [(sol['x'].real, sol['y'].real) for sol in dicpts]
print 'the real parts of the first ten points on the path :'
for point in coords:
    print point
Esempio n. 16
0
Get the x and y coordinates of a solution path.
First we take two quadrics and construct a start system
based on the total degree applying the theorem of Bezout.
To extract the coordinates of the points on a solution path,
we convert the string representation into a dictionary.
"""
f = ['x*y + y^2 - 8;', 'x^2 - 3*y + 4;']
print 'the polynomials in the target system :'
for pol in f:
    print pol
from phcpy.solver import total_degree_start_system as tds
(g, gsols) = tds(f)
print 'the polynomials in the start system :'
for pol in g:
    print pol
print 'number of start solutions :', len(gsols)
from phcpy.trackers import initialize_standard_tracker
from phcpy.trackers import initialize_standard_solution
from phcpy.trackers import next_standard_solution as nxtsol

initialize_standard_tracker(f, g)
initialize_standard_solution(len(g), gsols[0])
points = [nxtsol() for k in range(10)]
from phcpy.solutions import strsol2dict

dicpts = [strsol2dict(sol) for sol in points]
coords = [(sol['x'].real, sol['y'].real) for sol in dicpts]
print 'the real parts of the first ten points on the path :'
for point in coords:
    print point