def test_wright_fisher(N=20, lim=1e-10, n=2):
    """Test 2 dimensional Wright-Fisher process."""
    for n in [2, 3]:
        mu = (n - 1.) / n * 1. / (N + 1)
        m = numpy.ones((n, n))  # neutral landscape
        fitness_landscape = linear_fitness_landscape(m)
        incentive = replicator(fitness_landscape)

        # Wright-Fisher
        for low_memory in [True, False]:
            edge_func = wright_fisher.multivariate_transitions(
                N, incentive, mu=mu, num_types=n, low_memory=low_memory)
            states = list(simplex_generator(N, d=n - 1))
            for logspace in [False, True]:
                s = stationary_distribution(edge_func,
                                            states=states,
                                            iterations=200,
                                            lim=lim,
                                            logspace=logspace)
                wf_edges = edge_func_to_edges(edge_func, states)

                er = entropy_rate(wf_edges, s)
                assert_greater_equal(er, 0)

                # Check that the stationary distribution satistifies balance conditions
                check_detailed_balance(wf_edges, s, places=2)
                check_global_balance(wf_edges, s, places=4)
                check_eigenvalue(wf_edges, s, places=2)
def test_extrema_wf(lim=1e-10):
    """
    For small mu, the Wright-Fisher process is minimal in the center.
    Test that this happens.
    """

    for n, N, mins in [(2, 40, [(20, 20)]), (3, 30, [(10, 10, 10)])]:
        mu = 1. / N**3
        m = numpy.ones((n, n))  # neutral landscape
        fitness_landscape = linear_fitness_landscape(m)
        incentive = replicator(fitness_landscape)

        edge_func = wright_fisher.multivariate_transitions(N,
                                                           incentive,
                                                           mu=mu,
                                                           num_types=n)
        states = list(simplex_generator(N, d=n - 1))
        s = stationary_distribution(edge_func,
                                    states=states,
                                    iterations=4 * N,
                                    lim=lim)
        s2 = expected_divergence(edge_func, states=states, q_d=0)

        assert_equal(find_local_minima(s), set(mins))

        er = entropy_rate(edge_func, s, states=states)
        assert_greater_equal(er, 0)
示例#3
0
def test_wright_fisher(N=20, lim=1e-10, n=2):
    """Test 2 dimensional Wright-Fisher process."""
    for n in [2, 3]:
        mu = (n - 1.) / n * 1. / (N + 1)
        m = numpy.ones((n, n)) # neutral landscape
        fitness_landscape = linear_fitness_landscape(m)
        incentive = replicator(fitness_landscape)

        # Wright-Fisher
        for low_memory in [True, False]:
            edge_func = wright_fisher.multivariate_transitions(
                N, incentive, mu=mu, num_types=n, low_memory=low_memory)
            states = list(simplex_generator(N, d=n-1))
            for logspace in [False, True]:
                s = stationary_distribution(
                    edge_func, states=states, iterations=200, lim=lim,
                    logspace=logspace)
                wf_edges = edge_func_to_edges(edge_func, states)

                er = entropy_rate(wf_edges, s)
                assert_greater_equal(er, 0)

                # Check that the stationary distribution satistifies balance
                # conditions
                check_detailed_balance(wf_edges, s, places=2)
                check_global_balance(wf_edges, s, places=4)
                check_eigenvalue(wf_edges, s, places=2)
def test_extrema_moran_3(lim=1e-12):
    """
    Test for extrema of the stationary distribution.
    """
    n = 2
    N = 100
    mu = 6. / 25
    m = [[1, 0], [0, 1]]
    maxes = set([(38, 62), (62, 38)])
    mins = set([(50, 50), (100, 0), (0, 100)])
    fitness_landscape = linear_fitness_landscape(m)
    incentive = replicator(fitness_landscape)
    edges = incentive_process.multivariate_transitions(N,
                                                       incentive,
                                                       num_types=n,
                                                       mu=mu)
    s = stationary_distribution(edges, lim=lim)
    flow = inflow_outflow(edges)

    for q_d in [0, 1]:
        s2 = incentive_process.kl(edges, q_d=1)
        assert_equal(find_local_maxima(s), set(maxes))
        assert_equal(find_local_minima(s), set(mins))
        assert_equal(find_local_minima(s2), set([(50, 50), (40, 60),
                                                 (60, 40)]))
        assert_equal(find_local_maxima(flow), set(mins))
def test_incentive_process_k(lim=1e-14):
    """
    Compare stationary distribution computations to known analytic form for
    neutral landscape for the Moran process.
    """
    for k in [1, 2, 10,]:
        for n, N in [(2, 20), (2, 50), (3, 10), (3, 20)]:
            mu = (n-1.)/n * 1./(N+1)
            m = numpy.ones((n, n)) # neutral landscape
            fitness_landscape = linear_fitness_landscape(m)
            incentive = replicator(fitness_landscape)

            # Neutral landscape is the default
            edges = incentive_process.k_fold_incentive_transitions(
                N, incentive, num_types=n, mu=mu, k=k)
            stationary_1 = stationary_distribution(edges, lim=lim)

            # Check that the stationary distribution satisfies balance
            # conditions
            check_detailed_balance(edges, stationary_1)
            check_global_balance(edges, stationary_1)
            check_eigenvalue(edges, stationary_1)

            # Also check edge_func calculation
            edges = incentive_process.multivariate_transitions(
                N, incentive, num_types=n, mu=mu)
            states = states_from_edges(edges)
            edge_func = power_transitions(edges, k)
            stationary_2 = stationary_distribution(
                edge_func, states=states, lim=lim)

            for key in stationary_1.keys():
                assert_almost_equal(
                    stationary_1[key], stationary_2[key], places=5)
def test_extrema_moran_2(lim=1e-16):
    """
    Test for extrema of the stationary distribution.
    """
    n = 2
    N = 100
    mu = 1. / 1000
    m = [[1, 2], [3, 1]]
    maxes = set([(33, 67), (100,0), (0, 100)])
    fitness_landscape = linear_fitness_landscape(m)
    incentive = replicator(fitness_landscape)
    edges = incentive_process.multivariate_transitions(N, incentive, num_types=n, mu=mu)
    s = stationary_distribution(edges, lim=lim)
    s2 = expected_divergence(edges, q_d=0)

    assert_equal(find_local_maxima(s), set(maxes))
    assert_equal(find_local_minima(s2), set(maxes))
示例#7
0
def test_extrema_wf(lim=1e-10):
    """
    For small mu, the Wright-Fisher process is minimal in the center.
    Test that this happens.
    """

    for n, N, mins in [(2, 40, [(20, 20)]), (3, 30, [(10, 10, 10)])]:
        mu = 1. / N ** 3
        m = numpy.ones((n, n)) # neutral landscape
        fitness_landscape = linear_fitness_landscape(m)
        incentive = replicator(fitness_landscape)

        edge_func = wright_fisher.multivariate_transitions(
            N, incentive, mu=mu, num_types=n)
        states = list(simplex_generator(N, d=n-1))
        s = stationary_distribution(
            edge_func, states=states, iterations=4*N, lim=lim)
        assert_equal(find_local_minima(s), set(mins))
        er = entropy_rate(edge_func, s, states=states)
        assert_greater_equal(er, 0)
示例#8
0
def test_extrema_moran_3(lim=1e-12):
    """
    Test for extrema of the stationary distribution.
    """
    n = 2
    N = 100
    mu = 6./ 25
    m = [[1, 0], [0, 1]]
    maxes = set([(38, 62), (62, 38)])
    mins = set([(50, 50), (100, 0), (0, 100)])
    fitness_landscape = linear_fitness_landscape(m)
    incentive = replicator(fitness_landscape)
    edges = incentive_process.multivariate_transitions(N, incentive, num_types=n, mu=mu)
    s = stationary_distribution(edges, lim=lim)
    flow = inflow_outflow(edges)

    for q_d in [0, 1]:
        s2 = expected_divergence(edges, q_d=1)
        assert_equal(find_local_maxima(s), set(maxes))
        assert_equal(find_local_minima(s), set(mins))
        assert_equal(find_local_minima(s2), set([(50,50), (40, 60), (60, 40)]))
        assert_equal(find_local_maxima(flow), set(mins))
示例#9
0
def graph_test():
    """Test yen search on large process -- a two type neutral Moran process on
    a cycle."""
    def neighbor_function(state):
        """States in this case are a list of ones and zeroes, i.e. a graph
        coloring."""
        neighbors = []
        for i, t in enumerate(state):
            neighbor = copy.copy(list(state))
            if t == 0:
                neighbor[i] = 1
            else:
                neighbor[i] = 0
            neighbors.append(tuple(neighbor))
        return neighbors

    # print(neighbor_function([0, 1, 0]))

    def transition_function(source, target, mu=0.05):
        # Find the state that differs
        for i, (s, t) in enumerate(zip(source, target)):
            if s != t:
                break
        # i is now the index of the state that differs
        # Look at neighboring states (within the cycle) to determine transition
        N = len(source)
        indices = [i-1, i+1]
        transition = 0.
        for index in indices:
            if source[index % N] == s:
                transition += 1 - mu
            else:
                transition += mu
        return transition

    state = [0, 1, 0, 1, 0, 0]
    e = yen_search(state, neighbor_function, transition_function)
    print(e)

    state = [0, 1, 0, 1, 1, 1]
    e = yen_search(state, neighbor_function, transition_function)
    print(e)

    # state = [0, 0, 0, 1, 1, 1]
    # e = yen_search(state, neighbor_function, transition_function)
    # print(e)

    # Non-neutral landscape test

    m = [[1,2], [2,1]] # Hawk-Dove
    fitness_landscape = linear_fitness_landscape(m)
    incentive = replicator(fitness_landscape)

    def transition_function2(source, target, mu=0.01):
        """Non-neutral landscape specified by a game matrix (above)"""
        # Find the state that differs
        for i, (s, t) in enumerate(zip(source, target)):
            if s != t:
                break
        # i is now the index of the state that differs
        s = sum(source)
        N = len(source)
        population_state = (N - s, s)
        inc = incentive(population_state)
        denom = float(sum(inc))
        indices = [i-1, i+1]
        transition = 0.
        for index in indices:
            rep_type = source[index % N]
            r = float(inc[rep_type]) / denom
            if rep_type == s:
                transition += r * (1 - mu)
            else:
                transition += r * mu
        return transition

    state = [0, 1, 0, 1, 0, 1, 0, 1, 1, 0]
    e = yen_search(state, neighbor_function, transition_function2)
    print(e)

    state = [0, 1, 1, 0, 1, 1, 0, 0, 0, 1]
    e = yen_search(state, neighbor_function, transition_function2)
    print(e)

    state = [0, 1] * 8
    e = yen_search(state, neighbor_function, transition_function2)
    print(e)

    state = [0] * 8 + [1] * 8 + [0] * 8 + [1] * 8
    e = yen_search(state, neighbor_function, transition_function2)
    print(e)

    state = [0, 1] * 64
    e = yen_search(state, neighbor_function, transition_function2)
    print(e)

    state = [0] * 256 + [1] * 256
    e = yen_search(state, neighbor_function, transition_function2)
    print(e)

    state = [0, 1] * 64 + [1] * 4
    e = yen_search(state, neighbor_function, transition_function2,
                   extrema='min')
    print(e)

    state = [0] * 32 + [1, 0] + [1] * 32
    e = yen_search(state, neighbor_function, transition_function2,
                   extrema='min')
    print(e)

    # transition_function3()

    def transition_function3(source, target, mu=0.6):
        """Non-neutral landscape specified by a game matrix (above)"""
        # Find the state that differs
        for i, (s, t) in enumerate(zip(source, target)):
            if s != t:
                break
        # i is now the index of the state that differs
        s = sum(source)
        N = len(source)
        population_state = (N - s, s)
        inc = incentive(population_state)
        denom = float(sum(inc))
        indices = [i-1, i+1]
        transition = 0.
        for index in indices:
            rep_type = source[index % N]
            r = float(inc[rep_type]) / denom
            if rep_type == s:
                transition += r * (1 - mu)
            else:
                transition += r * mu
        return transition

    state = [0, 1, 0, 1, 0, 1, 0, 1, 1, 0]
    e = yen_search(state, neighbor_function, transition_function3)
    print(e)

    state = [0, 1, 1, 0, 1, 1, 0, 0, 0, 1]
    e = yen_search(state, neighbor_function, transition_function3)
    print(e)

    state = [0, 1] * 8
    e = yen_search(state, neighbor_function, transition_function3)
    print(e)

    state = [0, 1] * 64
    e = yen_search(state, neighbor_function, transition_function3)
    print(e)

    state = [0] * 128 + [1] * 128
    e = yen_search(state, neighbor_function, transition_function3)
    print(e)
        N = 10
    try:
        mu = sys.argv[2]
    except IndexError:
        mu = 1. / N

    #m = [[1,1], [1,1]]
    #m = [[1,2], [2,1]]
    #m = [[2,1],[1,2]]
    #m = [[2,2],[2,1]]
    m = [[2, 2], [1, 1]]
    print(N, m, mu)

    graph = cycle(N)
    fitness_landscape = linear_fitness_landscape(m)
    incentive = replicator(fitness_landscape)
    edge_dict = multivariate_graph_transitions(N,
                                               graph,
                                               incentive,
                                               num_types=2,
                                               mu=mu)
    edges = [(v1, v2, t) for ((v1, v2), t) in edge_dict.items()]
    g = Graph(edges)

    print("There are %s configurations and %s transitions" %
          (len(set([x[0] for x in edge_dict.keys()])), len(edge_dict)))

    print("Local Maxima:", len(find_extrema_yen(g, extrema="max")))
    print("Local Minima:", len(find_extrema_yen(g, extrema="min")))
    print("Total States:", 2**N)
示例#11
0
        N = 10
    try:
        mu = sys.argv[2]
    except IndexError:
        mu = 1./N

    #m = [[1,1], [1,1]]
    #m = [[1,2], [2,1]]
    #m = [[2,1],[1,2]]
    #m = [[2,2],[2,1]]
    m = [[2,2],[1,1]]
    print(N, m, mu)

    graph = cycle(N)
    fitness_landscape = linear_fitness_landscape(m)
    incentive = replicator(fitness_landscape)
    edge_dict = multivariate_graph_transitions(N, graph, incentive, num_types=2, mu=mu)
    edges = [(v1, v2, t) for ((v1, v2), t) in edge_dict.items()]
    g = Graph(edges)

    print("There are %s configurations and %s transitions" % (len(set([x[0] for x in edge_dict.keys()])), len(edge_dict)))

    print("Local Maxima:", len(find_extrema_yen(g, extrema="max")))
    print("Local Minima:", len(find_extrema_yen(g, extrema="min")))
    print("Total States:", 2**N)

    exit()
    print("Computing stationary")
    s = stationary_distribution(edges, lim=1e-8, iterations=1000)
    print("Local Maxima:", len(find_extrema_stationary(s, g, extrema="max")))
    print("Local Minima:", len(find_extrema_stationary(s, g, extrema="min")))