使用nextAfter（双启动，双向）；在Android中

我需要帮助。我将计算一个测量变量，然后取这些变量的前100个值并求平均值。请记住，我只是在过去的6周里自学，对某些人来说显而易见的东西，对我来说未必显而易见

本质上，假设‘double x’是一个变量，我有很多接近的值。我需要的是一种计算前100个值的总和（然后是平均值）的方法

在我的研究中，我能看到的最适合我需要的东西是“下一步（双启动，双向）；在此之前，使用“max”确定最大值，这是否是正确的起点：

双xm=最大值（x）； 静态双精度（xm，x

---

我的问题是如何得到前100个值的总和（最大值和99个下一个值）-平均很容易-只需除以100。

要计算从源代码读取的最大

n

值的平均值，至少需要存储这些值。由于在结束之前的任何给定点，您都不知道某些最大的

n

值是否会在稍后出现，因此您需要跟踪到目前为止看到的最大

n

值

一种简单的方法是将最大值存储在堆或优先级队列中，因为这样可以轻松添加新值并查找（和删除）最小的存储值。默认设置非常适合此任务，因为它使用元素的自然顺序，因此ing将删除最小的存储元素。如果要计算

n

最小元素的平均值，则需要使用带有自定义

比较器的
PriorityQueue
（或者在这种特殊情况下，简单地求反所有值并使用自然顺序也可以）

实现所需的延迟方式（更少的代码）是简单地将每个传入值添加到队列中，如果队列的大小超过
n
[那么它必须是
n+1
]从队列中删除最小的元素：

// vp is the value provider
while(vp.hasNext()) {
    // read the next value and add it to the queue
    pq.add(vp.nextValue());
    if (pq.size() > topSize) {
        pq.poll();
    }

稍微复杂一点的方法是首先检查是否需要添加新值，并仅在这种情况下修改队列

double newValue = vp.nextValue();
// Check if we have to put the new value in the queue
// that is the case when the queue is not yet full, or the smallest
// stored value is smaller than the new
if (pq.size() < topSize || pq.peek() < newValue) {
    // remove the smallest value from the queue only if it is full
    if (pq.size() == topSize()) {
        pq.poll();
    }
    pq.add(newValue);
}

使用接口

/**
 * Interface for a source of <code>double</code>s.
 */
public interface ValueProvider {
    /**
     * Gets the next value from the source.
     *
     * @return The next value if there is one.
     * @throws RuntimeException if the source is exhausted.
     */
    public double nextValue() throws RuntimeException;

    /**
     * Checks whether the source has more values to deliver.
     *
     * @return whether there is at least one more value to be obtained from the source.
     */
    public boolean hasNext();
}

和实现类

/**
 * Simple provider of a stream of <code>double</code>s.
 */
public class SimpleProvider implements ValueProvider {
    // State determining which value to return next.
    private long state = 0;
    // Last allowed state.
    private final long end;

    /**
     * Construct a provider of <code>e</code> values.
     *
     * @param e the number of values to yield.
     */
    public SimpleProvider(long e) {
        end = e > 0 ? e : 0;
    }

    /**
     * Default constructor to provide 10000 values.
     */
    public SimpleProvider() {
        this(10000);
    }

    public double nextValue() {
        ++state;
        return Math.log(state)*Math.sin(state) + Math.cos(state/2.0);
    }

    public boolean hasNext() {
        return state < end;
    }
}

我想你误解了
nextafter
，“The
nextafter（）
函数返回
x
之后的下一个可表示的浮点值，方向是
y
。它不知道你有什么值。啊-我明白你的意思…当，还有很多东西要学-有没有函数/命令可以提取前100个值？有没有“nextDown”版本的“nextUp”？或者我应该将我的值设为负值并使用nextUp命令…还是我又走错了方向？顺便问一下，是哪种语言？您必须在某些数据结构中至少收集前100个值。如果您在一个数组中收集所有值，您只需对其进行排序，然后从末尾提取100个值。如果您只想存储最大的100个值，则更多的参与（但如果你有很多价值观，速度会更快）。如何做取决于语言。啊，是的，我知道我忘了发布一些东西-我正在用Java做这件事-这是我正在开发的应用程序原型的一个重要部分。传奇！这正是我所追求的-我将在周末将这些代码合并到我的应用程序中，并让你知道我是如何做到的。谢谢你。只是一个简单的例子与此相关的另一个问题是，是否可以对相机预览的Y分量使用此排序方法？我不知道相机预览的Y分量是什么，以及它们可能需要什么样的特别注意。换句话说，对不起，我不知道。这没有问题-Y值是相机预览的灰度分量。不是吗恐怕你真的帮不了我。但是，只要你想根据比较从一个系列中抽取最大的项，你可以使用这种方法（在必要的修改后）。你需要调整数据类型（而不是双精度的，使用像素什么的），您可能需要为优先级队列提供一个
比较器
，以便只比较Y组件，但该算法的核心是通用的。
/**
 * Simple provider of a stream of <code>double</code>s.
 */
public class SimpleProvider implements ValueProvider {
    // State determining which value to return next.
    private long state = 0;
    // Last allowed state.
    private final long end;

    /**
     * Construct a provider of <code>e</code> values.
     *
     * @param e the number of values to yield.
     */
    public SimpleProvider(long e) {
        end = e > 0 ? e : 0;
    }

    /**
     * Default constructor to provide 10000 values.
     */
    public SimpleProvider() {
        this(10000);
    }

    public double nextValue() {
        ++state;
        return Math.log(state)*Math.sin(state) + Math.cos(state/2.0);
    }

    public boolean hasNext() {
        return state < end;
    }
}