Question

我正在尝试在java中实现概率分布函数，它在概率中返回数组中的i^th条目：

F_i = 6i(n-i) / (n³ - n)

其中n是数组长度，即数组长度为4：

P₁ = 3/10, P₂ = 4/10, P₃ = 3/10, P₄ = 0

请注意，此函数假设编号从1到n，而不是像Java一样编号为0到n-1。

目前我只是使用统一分布，即

 int i = (int)(Math.random()*((arraySize)-1));

使用-1因此它不会选择最后一个元素（即P _n = 0，如上例所示）。

有任何关于实施此方法的想法或提示的人吗？

Answer 1

这基本上是thomson_matt所说的，但更正式一点：你应该执行discrete inverse transform sampling。您的示例的伪代码：

p = [0.3, 0.4, 0.3. 0.0]
c = [0.3, 0.7, 1.0, 1.0] // cumulative sum

generate x uniformly in continuous range [0,1]
find max i such that c[i] < x.

Answer 2

double rand = Math.random(); // generate a random number in [0,1]
F=0;
// you test if rand is in [F(1)+..+F(i):F(1)+..+F(i)+F(i+1)] it is in this rnge with proba P(i) and therefore if it is in this range you return i
for (int i=1,i<array.size();i++ ){
   F+=F(i);
   if rand < F
       return i;
}
return array.size(); // you went through all the array then rand==1 (this probability is null) and you return n

Answer 3

要执行此操作，您需要将范围[0,1]划分为具有所需大小的区域。所以在这种情况下：

0 -> 0.0 - 0.3
1 -> 0.3 - 0.7
2 -> 0.7 - 1.0
3 -> 1.0 - 1.0

然后使用Math.random()生成一个随机数，并查看它落入的时间间隔。

通常，您希望执行以下伪代码：

double r = Math.random();
int i = -1;

while (r >= 0)
{
  i++;
  r -= F(i);
}

// i is now the value you want.

你在[0,1]上生成一个值，然后减去每个区间的大小，直到你低于0，此时你已经找到了你的随机值。

Answer 4

您可以尝试使用具有概率分布的可导航地图。与普通地图不同，NaviableMap定义了其键的绝对排序。如果地图中没有密钥，它可以告诉您哪个是最近的密钥，或者哪个是最大的密钥大于参数。我使用了ceilingEntry，它返回的地图条目的最小键大于或等于给定的键。

如果您使用TreeMap作为NavigableMap的实现，那么查找具有多个类的分布将更快，因为它执行二进制搜索而不是从第一个键开始，然后依次测试每个键。

NaviableMap的另一个优点是，您可以获得直接感兴趣的数据类，而不是另一个数组或列表的索引，这可以使代码更清晰。

在我的例子中，我使用了BigDecimals，因为我不是特别喜欢使用浮点数，因为你无法指定所需的精度。但你可以使用花车或双人或其他任何东西。

import java.math.BigDecimal;
import java.math.RoundingMode;
import java.util.Arrays;
import java.util.NavigableMap;
import java.util.TreeMap;


public class Main {

    public static void main(String[] args) {

        String[] classes = {"A", "B", "C", "D"};
        BigDecimal[] probabilities = createProbabilities(classes.length);
        BigDecimal[] distribution = createDistribution(probabilities);

        System.out.println("probabilities: "+Arrays.toString(probabilities));
        System.out.println("distribution: "+Arrays.toString(distribution)+"\n");

        NavigableMap<BigDecimal, String> map = new TreeMap<BigDecimal, String>();

        for (int i = 0; i < distribution.length; i++) {
            map.put(distribution[i], classes[i]);
        }

        BigDecimal d = new BigDecimal(Math.random());

        System.out.println("probability: "+d);

        System.out.println("result: "+map.ceilingEntry(d).getValue());

    }

    private static BigDecimal[] createDistribution(BigDecimal[] probabilities) {
        BigDecimal[] distribution = new BigDecimal[probabilities.length];

        distribution[0] = probabilities[0];
        for (int i = 1; i < distribution.length; i++) {
            distribution[i] = distribution[i-1].add(probabilities[i]); 
        }
        return distribution;
    }

    private static BigDecimal[] createProbabilities(int n) {
        BigDecimal[] probabilities = new BigDecimal[n];

        for (int i = 0; i < probabilities.length; i++) {
            probabilities[i] = F(i+1, n);
        }
        return probabilities;
    }

    private static BigDecimal F(int i, int n) {
//      6i(n-i) / (n3 - n)
        BigDecimal j = new BigDecimal(i);
        BigDecimal m = new BigDecimal(n);
        BigDecimal six = new BigDecimal(6);

        BigDecimal dividend = m.subtract(j).multiply(j).multiply(six);
        BigDecimal divisor = m.pow(3).subtract(m);

        return dividend.divide(divisor, 64, RoundingMode.HALF_UP);
    }
}

在Java中实现概率分布函数

4 个答案: