def qKq_uniform(num_samples: int, qrbf: QuadratureRBFUniformMeasure):
    if qrbf.integral_bounds is None:
        bounds = qrbf.measure.bounds
        samples = _sample_uniform(num_samples, bounds)
        qKx = qrbf.qK(samples)
        return np.mean(qKx)
    else:
        bounds = qrbf.integral_bounds._bounds
        samples = _sample_uniform(num_samples, bounds)
        qKx = qrbf.qK(samples) * qrbf.measure.compute_density(samples)[np.newaxis, :]
        differences = np.array([x[1] - x[0] for x in bounds])
        volume = np.prod(differences)
        return np.mean(qKx) * volume
def qK_uniform(num_samples: int, qrbf: QuadratureRBFUniformMeasure, x2: np.ndarray):
    if qrbf.integral_bounds is None:
        bounds = qrbf.measure.bounds
        samples = _sample_uniform(num_samples, bounds)
        Kx = qrbf.K(samples, x2)
        return np.mean(Kx, axis=0)
    else:
        bounds = qrbf.integral_bounds._bounds
        samples = _sample_uniform(num_samples, bounds)
        Kx = qrbf.K(samples, x2) * qrbf.measure.compute_density(samples)[:, np.newaxis]
        differences = np.array([x[1] - x[0] for x in bounds])
        volume = np.prod(differences)
        return np.mean(Kx, axis=0) * volume
def qrbf_uniform_infinite():
    x1 = np.array([[-1, 1], [0, 0], [-2, 0.1]])
    x2 = np.array([[-1, 1], [0, 0], [-2, 0.1], [-3, 3]])
    M1 = x1.shape[0]
    M2 = x2.shape[0]
    D = x1.shape[1]

    # measure
    measure_bounds = [(0, 2), (-4, 3)]
    measure = UniformMeasure(bounds=measure_bounds)

    gpy_kernel = GPy.kern.RBF(input_dim=D)
    emukit_rbf = RBFGPy(gpy_kernel)
    emukit_qrbf = QuadratureRBFUniformMeasure(rbf_kernel=emukit_rbf,
                                              integral_bounds=None,
                                              measure=measure)
    return emukit_qrbf, x1, x2, M1, M2, D
    gpy_kernel = GPy.kern.RBF(input_dim=D)
    emukit_rbf = RBFGPy(gpy_kernel)

    if MEASURE_INTBOUNDS == "Lebesgue-finite":
        emukit_qrbf = QuadratureRBFLebesgueMeasure(emukit_rbf,
                                                   integral_bounds=[(-1, 2),
                                                                    (-3, 3)])
    elif MEASURE_INTBOUNDS == "GaussIso-infinite":
        measure = IsotropicGaussianMeasure(mean=np.arange(D), variance=2.0)
        emukit_qrbf = QuadratureRBFIsoGaussMeasure(rbf_kernel=emukit_rbf,
                                                   measure=measure)
    elif MEASURE_INTBOUNDS == "Uniform-infinite":
        measure = UniformMeasure(bounds=[(0, 2), (-4, 3)])
        emukit_qrbf = QuadratureRBFUniformMeasure(emukit_rbf,
                                                  integral_bounds=None,
                                                  measure=measure)
    elif MEASURE_INTBOUNDS == "Uniform-finite":
        measure = UniformMeasure(bounds=[(1, 2), (-4, 2)])
        emukit_qrbf = QuadratureRBFUniformMeasure(emukit_rbf,
                                                  integral_bounds=[(-1, 2),
                                                                   (-3, 3)],
                                                  measure=measure)
    else:
        raise ValueError("Measure-integral-bounds combination not defined")

    print()
    print("measure: {}".format(MEASURE_INTBOUNDS))
    print("no dimensions: {}".format(D))
    print()