如何在 java 中获得白天的平均值和标准差

Question

对于用 Java 编写的 Android Studio 项目，我有一个白天列表，它以整数形式收集小时和分钟，如下所示：

List<Integer> times = new ArrayList<>();
int hour = 16;
int minute = 25;
int time = hour * 60 + minute;
times.add(time);

我需要时间的平均值和标准差才能获得非异常时间的列表。 但是，普通的平均值和标准差似乎不起作用。 这是我现在正在做的事情：

private List<String> getNonOutlierTimes() {

   int mean = convertToTime((times.stream().mapToInt(Integer::intValue).sum()) / times.size());
   int sd = (int) calculateStandardDeviation(mean);
   int maxTime = (int) (mean + 1.5 * sd);
   int minTime = (int) (mean - 1.5 * sd);

   List<Integer> nonOutliers = new ArrayList<>();

   for (int i = 0; i < times.size(); i++) {

       if ((times.get(i) <= maxTime) && (times.get(i) >= minTime)) {
                nonOutliers.add(times.get(i));
       }
   }

   List<String> nonOutliersStr = new ArrayList<>();

   for (Integer nonOutlier : nonOutliers) {
        nonOutliersStr.add(convertIntTimesToStr(nonOutlier));
   }

   return nonOutliersStr;
}


private int convertToTime(int a) {

   if ((a < 24*60) && (a >= 0)) {
            return a;
        } else if (a < 0) {
            return 24*60 + a;
        } else {
            return a % (24*60);
        }

}

private double calculateStandardDeviation(int mean) {

        int sum = 0;
        for (int j = 0; j < times.size(); j++) {
            int time = convertToTime(times.get(j));
            sum = sum + ((time - mean) * (time - mean));
        }
        double squaredDiffMean = (double) (sum) / (times.size());

        return (Math.sqrt(squaredDiffMean));
    }


private String convertIntTimesToStr(int time) {

        String hour = (time / 60) + "";
        int minute = time % 60;
        String minuteStr = minute < 10 ? "0" + minute : "" + minute;

        return hour + ":" + minuteStr;
    }

尽管所有计算都基于有效的统计数据，但计算出的平均值和 sd 似乎无关紧要。 例如，当时间列表包含以下内容时：

225 (03:45 am), 90 (01:30 am), 0 (12:00 am), 1420 (11:40 pm), 730 (12:10 pm)

我需要一个非异常值列表，其中包含：

1420（下午 11:40） 、0（上午 12:00）、90（上午 01:30）、225（上午 3:45）

其中实际的 output 是：

0（上午 12:00）、90（上午 1:30）、225（下午 3:45）、 730（下午 12:10）

即，我需要在大多数时候都处于平均水平。 更具体地说，考虑一个包含整数 1380（23:00 或 11:00 pm）、1400（23:20 或 11:20 pm）和 60（01:00 am）的时间列表。 这些时间的平均值是 945（15:45 或 03:45 pm），我需要平均值介于 23:00 和 01:00 之间。

我已经找到了两次列表的这个解决方案。 但是，我的 times.size() 总是大于 2，我也想计算标准偏差。 因此，我感谢您在这方面的帮助。

提前致谢。

Answer 1

您使用的不是实数，而是模 1440 的数字。在这种情况下，除以自然数没有很好的定义，或者更好nx = a对每个a都有n解。 例如， 3 x = 300 300解300 / 3 1740 / 3和3180 / 3 （ 1740和3180是相同元素300的不同表示）。

因此，您不能在一天中的时间范围内谈论算术平均值。 然而，一天中两个时间之间的距离是明确定义的：21:00 和 23:00 之间的距离是 2 小时，23:00 和 1:00 之间的距离也是如此。 因此，我们可以对“平均”采取另一种定义：

• 让我们称其为一天中最小化数据平方距离总和的时间。 这是实数的通常平均值的属性。

幸运的是，我们可以证明，这个新均值是nx = sum of values的解之一。 这些解决方案之间的变化是与数据的平方距离之和，我们必须选择最小的那个。

假设我们有一个LocalTime的列表：

   private static final long            DAY      = TimeUnit.DAYS.toSeconds(1L);
   private static final double          HALF_DAY = DAY / 2;
   private static final List<LocalTime> times    = Arrays.asList(
         LocalTime.of(3, 45),
         LocalTime.of(1, 30),
         LocalTime.of(0, 0),
         LocalTime.of(23, 40),
         LocalTime.of(12, 10));

我们可以计算“通常”确定中的平均值和平方和（我在几秒钟内完成，所以在 0 到 86400 之间）：

   public static void printMeanVariance(final List<LocalTime> times) {
      final List<Double> dTimes = times.stream().mapToDouble(LocalTime::toSecondOfDay).boxed().collect(Collectors.toList());
      dTimes.sort(Double::compareTo);
      // A valid 'mean' must have max - HALF_DAY < mean < min + HALF_DAY
      double max = dTimes.get(dTimes.size() - 1);
      int count = 0;
      double sum = 0.0, sumOfSquares = 0.0;
      for (final Double time : dTimes) {
         count++;
         sum += time;
         sumOfSquares += time * time;
      }
      // to be continued...

如果这是“平均值” ，则它必须满足两个条件：

1. “平均值”必须介于max + DAY和min + DAY之间，其中min和max是当前确定中的最小值和最大值，
2. 通常的方差必须最小。

我们通过将每次 86400 添加到最小值来检查所有确定的这些条件：

      // continuation
      double average = -1;
      double sumOfDistancesSquared = Double.MAX_VALUE;
      for (final Double time : dTimes) {
         // Check if previous value is admissible
         final double tmpAverage = sum / count;
         final double tmpSumOfDistancesSquared = sumOfSquares - sum * sum / count;
         if (max - HALF_DAY <= tmpAverage && tmpAverage <= time + HALF_DAY && tmpSumOfDistancesSquared < sumOfDistancesSquared) {
            average = tmpAverage;
            sumOfDistancesSquared = tmpSumOfDistancesSquared;
         }
         sum += DAY;
         max = time + DAY;
         sumOfSquares += DAY * (2 * time + DAY);
      }
      // average has the "real" mean
      double sd = Math.sqrt(sumOfDistancesSquared / (count - 1));
      System.out.println("Mean = " + LocalTime.ofSecondOfDay((long) average) +
        ", deviation = " + Duration.ofSeconds((long) sd));
   }
}