def update_db_pcoa(n_procs=4):
    def medoids(abd_tables, metadata):
        for userchunk in partition_by(zip(abd_tables, metadata), getpid):
            otu_tables = zip(*userchunk)[0]
            median = dict(process_pcoa.abundance_medoids(otu_tables))
            yield median

    dictify = lambda pids, points_list: dict(zip(pids, points_list))

    pids = dedupe(map(getpid, metadata))
    _, otu_tables, instances = zip(*metadata)
    bioms = list(process_pcoa.load_bioms(otu_tables))

    sampledist = process_pcoa.dist_array(bioms, len(bioms), n_procs=n_procs)
    samplepcoa = dictify(instances, process_pcoa.pcoa_coords(sampledist))
    meds = list(medoids(bioms, instances))
    userdist = process_pcoa.dist_array(meds, len(meds), n_procs=n_procs)
    userpcoa = dictify(pids, process_pcoa.pcoa_coords(userdist))

    sampledist, mask = process_pcoa.rm_outliers(sampledist)
    instances = take(instances, mask)
    userdist, mask = process_pcoa.rm_outliers(userdist)
    pids = take(pids, mask)
    f_userpcoa = dictify(pids, process_pcoa.pcoa_coords(userdist))
    f_samplepcoa = dictify(instances, process_pcoa.pcoa_coords(sampledist))

    global_user = models.User(models.GLOBAL_PID, db=db, load=True)
    global_user.state[models.User.PCOA_SAMPLE_KEY] = samplepcoa.values()
    global_user.state[models.User.PCOA_USER_KEY] = userpcoa.values()
    global_user.state[
        models.User.filtered.PCOA_SAMPLE_KEY] = f_samplepcoa.values()
    global_user.state[models.User.filtered.PCOA_USER_KEY] = f_userpcoa.values()

    def _users():
        for userchunk in partition_by(metadata, getpid):
            first, rest = peek(userchunk)
            rest = list(rest)
            pid = getpid(first)
            user = models.User(pid, db=db, load=True)
            if pid in f_userpcoa:
                user.state[
                    models.User.filtered.PCOA_USER_KEY] = f_userpcoa[pid]
            else:
                user.state[models.User.PCOA_USER_KEY] = userpcoa[pid]

            instances = [k[-1] for k in rest]
            if not all(k in f_samplepcoa for k in instances):
                user.state[models.User.PCOA_SAMPLE_KEY] = [
                    samplepcoa[k] for k in instances
                ]
            else:
                user.state[models.User.filtered.PCOA_SAMPLE_KEY] = [
                    f_samplepcoa[k] for k in instances
                ]
            yield user

    models.save_all(_users())
    global_user.state[models.User.MTIME_KEY] = NOW
    global_user.save()
def test_sol_earth_equal(rover, sol, limit):
    ed = nasa.sol_to_earth_date(rover, sol)
    by_sol = take(limit, nasa.get_mars_photos(rover, sol=sol))
    by_earth_date = take(limit, nasa.get_mars_photos(rover, earth_date=ed))

    for sol_photo, ed_photo in zip(by_sol, by_earth_date):
        assert sol_photo == ed_photo  # check metadata

        # following assertion should never fail as we ensured img_src are
        # the same by comparing metadata (if NASA's static server doesn't
        # give different images for the same urls, of course),
        # so this is only to add some image comparison to the task.
        assert not diff_img_by_urls(sol_photo['img_src'], ed_photo['img_src'])
示例#3
0
def player_take(field, symbol):
    while True:
        position = input('Which position do you choose for your take? ')
        if input_check(field, position) == 'ok':
            break
        print(input_check(field, position))
    return util.take(field, int(position)-1, symbol)
def main(biom_fnames, do_filter=False, n_procs=4, hsum_to="g__"):
    all_abds = load_bioms(biom_fnames, hsum_to=hsum_to)
    dist_arr = dist_array(all_abds, len(biom_fnames), n_procs=n_procs)
    if do_filter:
        dist_arr, mask = rm_outliers(dist_arr)
        biom_fnames = take(biom_fnames, mask)
    pcoa_arr = pcoa_coords(dist_arr)
    return zip(biom_fnames, pcoa_arr)
示例#5
0
def find_smooth(n, fb, lim=20):
    try:
        xis, yis, evecs = zip(*take(len(fb) + 1, smooth_iter(n, fb, lim)))
        emat = [[evec.get(p, 0) for p in fb] for evec in evecs]
        bmat = [[a % 2 for a in row] for row in emat]
        return (xis, yis, emat, bmat)
    except:
        return None
示例#6
0
文件: ai.py 项目: alby-m/pyladies
def pc_take(field, symbol):
    if field.count('-') == 0:
        raise ValueError('Field has no available spots for new take.')
    while True:
        position = randrange(len(field))
        if field[position] != '-':
            continue
        break
    return util.take(field, position, symbol)
示例#7
0
文件: core.py 项目: jdmcbr/logpy
def run(n, x, *goals):
    """ Run a logic program.  Obtain n solutions to satisfy goals.

    n     - number of desired solutions.  See ``take``
            0 for all
            None for a lazy sequence
    x     - Output variable
    goals - a sequence of goals.  All must be true

    >>> from logpy import run, var, eq
    >>> run(1, x, eq(x, 1))
    (1,)
    """
    return take(n, unique(walkstar(x, s) for s in bindstar(({},), *goals)))
示例#8
0
def run(n, x, *goals, **kwargs):
    """ Run a logic program.  Obtain n solutions to satisfy goals.

    n     - number of desired solutions.  See ``take``
            0 for all
            None for a lazy sequence
    x     - Output variable
    goals - a sequence of goals.  All must be true

    >>> from logpy import run, var, eq
    >>> run(1, x, eq(x, 1))
    (1,)
    """
    return take(n, unique(reify(x, s) for s in goaleval(lallearly(*goals))({})))
示例#9
0
文件: core.py 项目: danielggc/python
def run(n, x, *goals, **kwargs):
    """ Run a logic program.  Obtain n solutions to satisfy goals.

    n     - number of desired solutions.  See ``take``
            0 for all
            None for a lazy sequence
    x     - Output variable
    goals - a sequence of goals.  All must be true

    >>> from logpy import run, var, eq
    >>> x = var()
    >>> run(1, x, eq(x, 1))
    (1,)
    """
    return take(n,
                unique(reify(x, s) for s in goaleval(lallearly(*goals))({})))
示例#10
0
def find_smooth(n, b, I):
    m = ceil(sqrt(n))
    # Sieve from sieving interval
    V = [(x + m)**2 - n for x in range(I)]
    # In tandem, find b primes p for which n has roots modulo p
    p_root_pairs = list(take(b, iter_roots(n)))
    fb, roots = zip(*p_root_pairs)
    # Sieve!
    for (p, roots) in p_root_pairs:
        for r in roots:
            start = (r - m) % p
            for i in range(start, len(V), p):
                while V[i] % p == 0:
                    V[i] //= p
    # Construct, collect and return the x's and y's (which are smooth)
    xs = [i + m for (i, v) in enumerate(V) if abs(v) == 1]
    ys = [x**2 - n for x in xs]
    return (xs, ys, fb)
示例#11
0
def analyze_lambda_expr(self, Γ, args, e):
    arg_ids = tuple(U.take(len(args), U.fresh_ids))
    arg_types = [T.EVar(name) for name in arg_ids]
    Γ1 = Γ.copy()
    for a, t in zip(map(U.ident2str, args), arg_types):
        Γ1.annotate(a, t, fixed=True)
    Γ2, t < -self.analyze([Γ1], e)
    #print('Γ2 =', Γ2)
    #print('t =', t, '=>', t.under(Γ2))
    #print('args =', ', '.join(map(str, arg_types)))
    fn = T.Fun(T.Tuple(arg_types), t).under(Γ2)
    #print('Γ =', Γ)
    for name in Γ.Γ:
        t_Γ = Γ.typeof(name)
        t_Γ2 = t_Γ.under(Γ2)
        Γ.unify(t_Γ, t_Γ2)
        Γ.fix(t_Γ2.names() & (Γ2.fixed - Γ1.fixed))
    #print('new Γ =', Γ)
    #print('returning', fn)
    #print()
    return [(Γ, fn)]
示例#12
0
import psyco
import util

NUM = 100000

def triangles():
    n = 0
    while True:
        yield n * (n + 1) / 2
        n += 1

triangles = set(util.take(NUM, triangles()))

def pentagonals():
    n = 0
    while True:
        yield n * (3 * n - 1) / 2
        n += 1

pentagonals = set(util.take(NUM, pentagonals()))

def hexagonals():
    n = 0
    while True:
        yield n * (2 * n - 1)
        n += 1

hexagonals = set(util.take(NUM, hexagonals()))

print sorted(triangles.intersection(pentagonals).intersection(hexagonals))
示例#13
0
import sys

import matplotlib.pyplot as plt
import util

if __name__ == '__main__':

    plt.ylabel("average time in milliseconds")

    for filename in sys.argv[1:]:
        info = util.take(filename)
        plt.plot(info.xAxis, info.yAxis, label=info.serverType)

        plt.xlabel(info.testingType)
        title = "number of requests = " + str(info.requestNumber) + '\n'
        if info.testingType != util.TestingType.ARRAY_SIZE:
            title += "size of array = " + str(info.arraySize) + "; "
        if info.testingType != util.TestingType.CLIENTS_NUMBER:
            title += "number of clients = " + str(info.clientsNumber) + "; "
        if info.testingType != util.TestingType.SENDING_DELTA:
            title += "delta of sending = " + str(info.sendingDelta) + "; "
        plt.title(title)

    plt.legend()
    plt.show()
示例#14
0
#
# Uses the Legendre symbol (i.e. Euler's criterion).
# Note: every integer is a quadratic residue modulo 2.
#
# @param n An integer
# @param p A prime (not necessarily odd, i.e. can be 2)
# @return Whether integer n is a quadratic residue modulo odd prime p
def is_quadratic_residue(n, p):
    return legendre(n, p) == 1 if p > 2 else True


# Iterator over primes for which an integer is a quadratic residue.
#
# @param n An integer
# @param start (default=2) Starting integer (nearest prime greater-than or equal to this)
# @yields Primes $p_j,p_{j+1},\ldots$ for which integer n is a quadratic residue modulo $p_i$
#   for $i>=j$
def legendre_primes(n, start=2):
    for p in primes(start):
        if is_quadratic_residue(n, p):
            yield p


if __name__ == '__main__':
    from util import take
    import sys
    n = int(sys.argv[1])
    b = int(sys.argv[2])
    for (i, p) in enumerate(take(b, legendre_primes(n))):
        print(i, p)
示例#15
0
def test_take():
    field = util.take('--------------------', 1, 'o')
    assert field[1] == 'o'
    assert len(field) == 20
    assert field.count('o') == 1
    assert field.count('-') == 19