def test_Lp_generalized_normal():
    """
    Tests :meth:`bet.Lp_generalized_samples.Lp_generalized_normal`

    This test only verifies the mean, but not the variance.

    """
    # 1D
    nptest.assert_allclose(np.mean(lp.Lp_generalized_normal(1, 1000), 0),
                           np.zeros((1,)), atol=1e-1)
    # 2D
    nptest.assert_allclose(np.mean(lp.Lp_generalized_normal(2, 1000), 0),
                           np.zeros((2,)), atol=1e-1)
    # 3D
    nptest.assert_allclose(np.mean(lp.Lp_generalized_normal(3, 1000), 0),
                           np.zeros((3,)), atol=1e-1)
def test_Lp_generalized_uniform():
    """
    Tests :meth:`bet.Lp_generalized_samples.Lp_generalized_uniform`

    This test only verifies the mean, but not the variance.

    """
    # 1D
    x = lp.Lp_generalized_uniform(1, 1000)
    nptest.assert_allclose(np.mean(x, 0), np.zeros((1,)), atol=1e-1)
    assert np.all(np.logical_and(x <= 1., x >= -1))

    # 2D
    p = 1
    x = lp.Lp_generalized_uniform(2, 1000, p)
    verify_norm_and_mean(x, 1.0, p)

    p = 2
    x = lp.Lp_generalized_uniform(2, 1000, p)
    verify_norm_and_mean(x, 1.0, p)

    p = 3
    x = lp.Lp_generalized_uniform(2, 1000, p)
    verify_norm_and_mean(x, 1.0, p)

    p = np.inf
    x = lp.Lp_generalized_uniform(2, 1000, p)
    verify_norm_and_mean(x, 1.0, p)

    # 3D
    p = 1
    x = lp.Lp_generalized_uniform(3, 1000, p)
    verify_norm_and_mean(x, 1.0, p)

    p = 2
    x = lp.Lp_generalized_uniform(3, 1000, p)
    verify_norm_and_mean(x, 1.0, p)

    p = 3
    x = lp.Lp_generalized_uniform(3, 1000, p)
    verify_norm_and_mean(x, 1.0, p)

    p = np.inf
    x = lp.Lp_generalized_uniform(3, 1000, p)
    verify_norm_and_mean(x, 1.0, p)
示例#3
0
def sample_lp_ball(input_set, num_close, radius, p_num=2):
    r"""
    Pick num_close points in a the Lp ball of length 2*``radii_vec`` around a
    point in the input space, do this for each point in centers.  If this box
    extends outside of the domain of the input space, we sample the
    intersection.

    :param input_set: The input sample set.  Make sure the attribute
        ``_values`` is not ``None``
    :type input_set: :class:`~bet.sample.sample_set`
    :param int num_close: Number of points in each cluster
    :param radii_vec: Each side of the box will have length ``2*radii_vec[i]``
    :type radii_vec: :class:`numpy.ndarray` of shape (``input_dim``,)
    :param float p_num: :math:`0 < p \leq \infty`, p for the lp norm where
        infinity is ``numpy.inf``
    
    :rtype: :class:`~bet.sample.sample_set`
    :returns: Centers and clusters of samples near each center (values are 
        :class:`numpy.ndarray` of shape ((``num_close+1``)*``num_centers``,
        ``input_dim``))
    
    """
    if input_set.get_values() is None:
        raise ValueError("You must have values to use this method.")
    input_dim = input_set.get_dim()
    centers = input_set.get_values()
    num_centers = input_set.check_num()
    input_domain = input_set.get_domain()

    cluster_set = sample.sample_set(input_dim)
    if input_domain is not None:
        cluster_set.set_domain(input_domain)
    cluster_set.set_values(centers)

    for i in xrange(num_centers):
        in_bounds = 0
        inflate = 1.0
        while in_bounds < num_close:
            # sample uniformly
            new_cluster = lpsam.Lp_generalized_uniform(input_dim,
                                                       num_close * inflate,
                                                       p_num, radius,
                                                       centers[i, :])
            # check bounds
            if input_domain is not None:
                cluster_set.update_bounds(num_close * inflate)
                left = np.all(np.greater_equal(new_cluster, cluster_set._left),
                              axis=1)
                right = np.all(np.less_equal(new_cluster, cluster_set._right),
                               axis=1)
                inside = np.logical_and(left, right)
                in_bounds = np.sum(inside)
                new_cluster = new_cluster[inside, :]
                # increase inflate
                inflate *= 10.0
            else:
                in_bounds = num_close

        if in_bounds > num_close:
            new_cluster = new_cluster[:num_close, :]
        cluster_set.append_values(new_cluster)

    # reset bounds
    cluster_set._left = None
    cluster_set._right = None
    cluster_set._width = None
    return cluster_set