Я на самом деле очень удивлен, что не смог найти ответ на этот вопрос здесь, хотя, возможно, я просто использую неправильные условия поиска или что-то в этом роде. Самое близкое, что я мог бы найти, это , но они спрашивают о генерации определенного диапазона doubles с определенным размером шага, и ответы рассматривают это как таковой. Мне нужно что-то, что будет генерировать числа с произвольным размером начала, конца и шага.
Я полагаю, что где-то уже должен быть какой-то метод, подобный этому, в библиотеке, но если это так, я не смог найти его легко (опять же, возможно, я просто использую неправильные условия поиска или что-то в этом роде). Итак, вот что я приготовил самостоятельно за последние несколько минут, чтобы сделать это:
import java.lang.Math;
import java.util.List;
import java.util.ArrayList;
public class DoubleSequenceGenerator {
/**
* Generates a List of Double values beginning with `start` and ending with
* the last step from `start` which includes the provided `end` value.
**/
public static List<Double> generateSequence(double start, double end, double step) {
Double numValues = (end-start)/step + 1.0;
List<Double> sequence = new ArrayList<Double>(numValues.intValue());
sequence.add(start);
for (int i=1; i < numValues; i++) {
sequence.add(start + step*i);
}
return sequence;
}
/**
* Generates a List of Double values beginning with `start` and ending with
* the last step from `start` which includes the provided `end` value.
*
* Each number in the sequence is rounded to the precision of the `step`
* value. For instance, if step=0.025, values will round to the nearest
* thousandth value (0.001).
**/
public static List<Double> generateSequenceRounded(double start, double end, double step) {
if (step != Math.floor(step)) {
Double numValues = (end-start)/step + 1.0;
List<Double> sequence = new ArrayList<Double>(numValues.intValue());
double fraction = step - Math.floor(step);
double mult = 10;
while (mult*fraction < 1.0) {
mult *= 10;
}
sequence.add(start);
for (int i=1; i < numValues; i++) {
sequence.add(Math.round(mult*(start + step*i))/mult);
}
return sequence;
}
return generateSequence(start, end, step);
}
}Эти методы запускают простой цикл, умножая stepего на индекс последовательности и добавляя к startсмещению. Это уменьшает сложность ошибок с плавающей запятой, которые могут возникнуть при непрерывном увеличении (например, добавлениеstep переменной в каждую итерацию).
Я добавил generateSequenceRoundedметод для тех случаев, когда размер дробного шага может вызвать заметные ошибки с плавающей точкой. Это требует немного большей арифметики, поэтому в таких чрезвычайно чувствительных к производительности ситуациях, как наша, было бы неплохо иметь возможность использовать более простой метод, когда округление не требуется. Я подозреваю, что в большинстве случаев общего использования издержки округления будут незначительными.
Обратите внимание , что я намеренно исключил логику для обработки «ненормальные» аргументов , таких как Infinity, NaN, start> end, или отрицательногоstep размера для простоты и желание сосредоточиться на вопрос под руку.
Вот пример использования и соответствующий вывод:
System.out.println(DoubleSequenceGenerator.generateSequence(0.0, 2.0, 0.2))
System.out.println(DoubleSequenceGenerator.generateSequenceRounded(0.0, 2.0, 0.2));
System.out.println(DoubleSequenceGenerator.generateSequence(0.0, 102.0, 10.2));
System.out.println(DoubleSequenceGenerator.generateSequenceRounded(0.0, 102.0, 10.2));[0.0, 0.2, 0.4, 0.6000000000000001, 0.8, 1.0, 1.2000000000000002, 1.4000000000000001, 1.6, 1.8, 2.0]
[0.0, 0.2, 0.4, 0.6, 0.8, 1.0, 1.2, 1.4, 1.6, 1.8, 2.0]
[0.0, 10.2, 20.4, 30.599999999999998, 40.8, 51.0, 61.199999999999996, 71.39999999999999, 81.6, 91.8, 102.0]
[0.0, 10.2, 20.4, 30.6, 40.8, 51.0, 61.2, 71.4, 81.6, 91.8, 102.0]Существует ли уже существующая библиотека, которая уже обеспечивает такую функциональность?
Если нет, есть ли проблемы с моим подходом?
У кого-нибудь есть лучший подход к этому?