Пример #1
0
def ade_tuned_double_track(target, start, sols, pars, gamma=0, verbose=1):
    r"""
    Does path tracking with algorithm differentiation,
    in standard double precision, with tuned parameters in pars.
    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.phcpy2c2 import py2c_copy_standard_container_to_target_system
    from phcpy.phcpy2c2 import py2c_copy_standard_container_to_start_system
    from phcpy.phcpy2c2 import py2c_ade_manypaths_d_pars
    from phcpy.interface import store_standard_system
    from phcpy.interface import store_standard_solutions
    from phcpy.interface import load_standard_solutions
    store_standard_system(target)
    py2c_copy_standard_container_to_target_system()
    store_standard_system(start)
    py2c_copy_standard_container_to_start_system()
    dim = len(start)
    store_standard_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_d_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_standard_solutions()
Пример #2
0
def standard_double_track(target, start, sols, gamma=0, tasks=0):
    r"""
    Does path tracking with standard double precision.
    On input are a target system, a start system with solutions,
    optionally: a (random) *gamma* constant and the number of *tasks*.
    The default value zero for *tasks* indicates no multithreading.
    The number of tasks in the multithreading is given by *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_standard_container_to_target_system
    from phcpy.phcpy2c2 import py2c_copy_standard_container_to_start_system
    from phcpy.phcpy2c2 import py2c_copy_standard_container_to_start_solutions
    from phcpy.phcpy2c2 import py2c_create_standard_homotopy
    from phcpy.phcpy2c2 import py2c_create_standard_homotopy_with_gamma
    from phcpy.phcpy2c2 import py2c_solve_by_standard_homotopy_continuation
    from phcpy.phcpy2c2 import py2c_solcon_clear_standard_solutions
    from phcpy.phcpy2c2 import py2c_copy_standard_target_solutions_to_container
    from phcpy.interface import store_standard_system
    from phcpy.interface import store_standard_solutions
    from phcpy.interface import load_standard_solutions
    from phcpy.solver import number_of_symbols
    dim = number_of_symbols(start)
    store_standard_system(target, nbvar=dim)
    py2c_copy_standard_container_to_target_system()
    store_standard_system(start, nbvar=dim)
    py2c_copy_standard_container_to_start_system()
    # py2c_clear_standard_homotopy()
    if(gamma == 0):
        py2c_create_standard_homotopy()
    else:
        py2c_create_standard_homotopy_with_gamma(gamma.real, gamma.imag)
    store_standard_solutions(dim, sols)
    py2c_copy_standard_container_to_start_solutions()
    py2c_solve_by_standard_homotopy_continuation(tasks)
    py2c_solcon_clear_standard_solutions()
    py2c_copy_standard_target_solutions_to_container()
    return load_standard_solutions()
Пример #3
0
def ade_double_track(target, start, sols, gamma=0, verbose=1):
    """
    Does path tracking with algorithm differentiation,
    in standard 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_standard_container_to_target_system
    from phcpy.phcpy2c2 import py2c_copy_standard_container_to_start_system
    from phcpy.phcpy2c2 import py2c_ade_manypaths_d
    from phcpy.interface import store_standard_system
    from phcpy.interface import store_standard_solutions
    from phcpy.interface import load_standard_solutions

    store_standard_system(target)
    py2c_copy_standard_container_to_target_system()
    store_standard_system(start)
    py2c_copy_standard_container_to_start_system()
    dim = len(start)
    store_standard_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_ade_manypaths_d(verbose, gamma.real, gamma.imag)
    if fail == 0:
        if verbose > 0:
            print "Path tracking with AD was a success!"
    else:
        print "Path tracking with AD failed!"
    return load_standard_solutions()
Пример #4
0
def initialize_standard_tracker(target, start, fixedgamma=True):
    r"""
    Initializes a path tracker with a generator for a *target*
    and *start* system given in standard double precision.
    If *fixedgamma*, then gamma will be a fixed default value,
    otherwise, a random complex constant for gamma is generated.
    """
    from phcpy.phcpy2c2 import py2c_copy_standard_container_to_target_system
    from phcpy.phcpy2c2 import py2c_copy_standard_container_to_start_system
    from phcpy.phcpy2c2 import py2c_initialize_standard_homotopy
    from phcpy.interface import store_standard_system
    store_standard_system(target)
    py2c_copy_standard_container_to_target_system()
    store_standard_system(start)
    py2c_copy_standard_container_to_start_system()
    if fixedgamma:
        return py2c_initialize_standard_homotopy(1)
    else:
        return py2c_initialize_standard_homotopy(0)
Пример #5
0
def standard_diagonal_homotopy(dim1, sys1, esols1, dim2, sys2, esols2):
    r"""
    Defines a diagonal homotopy to intersect the witness sets defined
    by (*sys1*, *esols1*) and (*sys2*, *esols2*), respectively of dimensions
    *dim1* and *dim2*.  The systems *sys1* and *sys2* are assumed to be square
    and with as many slack variables as the dimension of the solution sets.
    The data is stored in standard double precision.
    """
    from phcpy.interface import store_standard_system as storesys
    from phcpy.interface import store_standard_solutions as storesols
    from phcpy.phcpy2c2 import py2c_copy_standard_container_to_target_system
    from phcpy.phcpy2c2 import py2c_copy_standard_container_to_target_solutions
    from phcpy.phcpy2c2 import py2c_copy_standard_container_to_start_system
    from phcpy.phcpy2c2 import py2c_copy_standard_container_to_start_solutions
    from phcpy.phcpy2c2 import py2c_standard_diagonal_homotopy
    from phcpy.phcpy2c2 import py2c_syscon_number_of_symbols
    from phcpy.phcpy2c2 import py2c_syscon_string_of_symbols
    from phcpy.phcpy2c2 import py2c_diagonal_symbols_doubler
    storesys(sys1)
    symbols = py2c_syscon_string_of_symbols()
    nbsymbs = py2c_syscon_number_of_symbols()
    print 'number of symbols :', nbsymbs
    print 'names of variables :', symbols
    storesols(len(sys1), esols1)
    if(dim1 >= dim2):
        py2c_copy_standard_container_to_target_system()
        py2c_copy_standard_container_to_target_solutions()
    else:
        py2c_copy_standard_container_to_start_system()
        py2c_copy_standard_container_to_start_solutions()
    storesys(sys2)
    storesols(len(sys2), esols2)
    if(dim1 >= dim2):
        py2c_copy_standard_container_to_start_system()
        py2c_copy_standard_container_to_start_solutions()
    else:
        py2c_copy_standard_container_to_target_system()
        py2c_copy_standard_container_to_target_solutions()
    if(dim1 >= dim2):
        py2c_standard_diagonal_homotopy(dim1, dim2)
    else:
        py2c_standard_diagonal_homotopy(dim2, dim1)
    py2c_diagonal_symbols_doubler(nbsymbs-dim1, dim1, len(symbols), symbols)
Пример #6
0
def gpu_double_track(target, start, sols, gamma=0, verbose=1):
    r"""
    GPU accelerated path tracking with algorithm differentiation,
    in standard 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_standard_container_to_target_system
    from phcpy.phcpy2c2 import py2c_copy_standard_container_to_start_system
    from phcpy.phcpy2c2 import py2c_gpu_manypaths_d
    from phcpy.interface import store_standard_system
    from phcpy.interface import store_standard_solutions
    from phcpy.interface import load_standard_solutions
    store_standard_system(target)
    py2c_copy_standard_container_to_target_system()
    store_standard_system(start)
    py2c_copy_standard_container_to_start_system()
    dim = len(start)
    store_standard_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_d(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_standard_solutions()