Как уменьшить диапазон чисел с известным значением min и max
поэтому я пытаюсь выяснить, как взять диапазон чисел и масштабировать значения вниз, чтобы соответствовать диапазону. Причина желания сделать это заключается в том, что я пытаюсь нарисовать эллипсы в Java swing jpanel. Я хочу, чтобы высота и ширина каждого эллипса будет в диапазоне, скажем, 1-30. У меня есть методы, которые находят минимальные и максимальные значения из моего набора данных, но у меня не будет min и max до выполнения. Существует ли простой способ сделать это?
6 ответов
предположим, вы хотите масштабировать диапазон [min,max]
до [a,b]
. Вы ищете (непрерывную) функцию, которая удовлетворяет
f(min) = a
f(max) = b
в вашем случае, a
будет 1 и b
было бы 30, но давайте начнем с чего-то более простого и попробуем сопоставить [min,max]
в серии [0,1]
.
положить min
в функцию и выход 0 может быть выполнен с помощью
f(x) = x - min ===> f(min) = min - min = 0
так это почти то, что мы хотим. Но положить в max
будет дай нам max - min
когда мы действительно хотим 1. Поэтому нам придется масштабировать его:
x - min max - min
f(x) = --------- ===> f(min) = 0; f(max) = --------- = 1
max - min max - min
чего мы и хотим. Поэтому нам нужно сделать перевод и масштабирование. Теперь, если вместо этого мы хотим получить произвольные значения a
и b
, нам нужно что-то посложнее:
(b-a)(x - min)
f(x) = -------------- + a
max - min
можно проверить, указав min
на x
теперь a
, и указав max
дает b
.
вы также можете заметить, что (b-a)/(max-min)
- это коэффициент масштабирования между размером нового диапазона и размером исходного диапазона. Так действительно мы сначала переводим x
by -min
, масштабируя его до правильного коэффициента, а затем переводя его обратно до нового минимального значения a
.
надеюсь, что это помогает.
вот некоторые JavaScript для легкости копирования-вставки (это ответ раздражает):
function scaleBetween(unscaledNum, minAllowed, maxAllowed, min, max) {
return (maxAllowed - minAllowed) * (unscaledNum - min) / (max - min) + minAllowed;
}
применяется так, масштабирование диапазона 10-50 до диапазона между 0-100.
var unscaledNums = [10, 13, 25, 28, 43, 50];
var maxRange = Math.max.apply(Math, unscaledNums);
var minRange = Math.min.apply(Math, unscaledNums);
for (var i = 0; i < unscaledNums.length; i++) {
var unscaled = unscaledNums[i];
var scaled = scaleBetween(unscaled, 0, 100, minRange, maxRange);
console.log(scaled.toFixed(2));
}
0.00, 18.37, 48.98, 55.10, 85.71, 100.00
Edit:
Я знаю, что я ответил на это давно, но вот более чистая функция, которую я использую сейчас:
Array.prototype.scaleBetween = function(scaledMin, scaledMax) {
var max = Math.max.apply(Math, this);
var min = Math.min.apply(Math, this);
return this.map(num => (scaledMax-scaledMin)*(num-min)/(max-min)+scaledMin);
}
вот так:
[-4, 0, 5, 6, 9].scaleBetween(0, 100);
[0, 30.76923076923077, 69.23076923076923, 76.92307692307692, 100]
для удобства, вот алгоритм Irritate в форме Java. Добавьте проверку ошибок, обработку исключений и настройку по мере необходимости.
public class Algorithms {
public static double scale(final double valueIn, final double baseMin, final double baseMax, final double limitMin, final double limitMax) {
return ((limitMax - limitMin) * (valueIn - baseMin) / (baseMax - baseMin)) + limitMin;
}
}
тестер:
final double baseMin = 0.0;
final double baseMax = 360.0;
final double limitMin = 90.0;
final double limitMax = 270.0;
double valueIn = 0;
System.out.println(Algorithms.scale(valueIn, baseMin, baseMax, limitMin, limitMax));
valueIn = 360;
System.out.println(Algorithms.scale(valueIn, baseMin, baseMax, limitMin, limitMax));
valueIn = 180;
System.out.println(Algorithms.scale(valueIn, baseMin, baseMax, limitMin, limitMax));
90.0
270.0
180.0
я столкнулся с этим решением, но это не совсем соответствует моей потребности. Поэтому я немного покопался в исходном коде d3. Я лично рекомендовал бы сделать это как d3.шкалы делает.
Итак, здесь вы масштабируете домен до диапазона. Преимущество в том, что вы можете переворачивать знаки в свой целевой диапазон. Это полезно, Так как ось Y на экране компьютера идет сверху вниз, поэтому большие значения имеют небольшой y.
public class Rescale {
private final double range0,range1,domain0,domain1;
public Rescale(double domain0, double domain1, double range0, double range1) {
this.range0 = range0;
this.range1 = range1;
this.domain0 = domain0;
this.domain1 = domain1;
}
private double interpolate(double x) {
return range0 * (1 - x) + range1 * x;
}
private double uninterpolate(double x) {
double b = (domain1 - domain0) != 0 ? domain1 - domain0 : 1 / domain1;
return (x - domain0) / b;
}
public double rescale(double x) {
return interpolate(uninterpolate(x));
}
}
и вот это тест, где вы можете увидеть, что я имею в виду
public class RescaleTest {
@Test
public void testRescale() {
Rescale r;
r = new Rescale(5,7,0,1);
Assert.assertTrue(r.rescale(5) == 0);
Assert.assertTrue(r.rescale(6) == 0.5);
Assert.assertTrue(r.rescale(7) == 1);
r = new Rescale(5,7,1,0);
Assert.assertTrue(r.rescale(5) == 1);
Assert.assertTrue(r.rescale(6) == 0.5);
Assert.assertTrue(r.rescale(7) == 0);
r = new Rescale(-3,3,0,1);
Assert.assertTrue(r.rescale(-3) == 0);
Assert.assertTrue(r.rescale(0) == 0.5);
Assert.assertTrue(r.rescale(3) == 1);
r = new Rescale(-3,3,-1,1);
Assert.assertTrue(r.rescale(-3) == -1);
Assert.assertTrue(r.rescale(0) == 0);
Assert.assertTrue(r.rescale(3) == 1);
}
}
вот как я понимаю:
какой процент x
лежать в диапазоне
предположим, у вас есть диапазон от 0
to 100
. Учитывая произвольное число из этого диапазона, в каком "проценте" из этого диапазона оно находится? Это должно быть довольно просто, 0
будет 0%
, 50
будет 50%
и 100
будет 100%
.
теперь, что если ваш выбор был 20
to 100
? Мы не можем применить то же самое логика, как указано выше (разделить на 100), потому что:
20 / 100
не дает нам 0
(20
должно быть 0%
сейчас). Это должно быть просто исправить, нам просто нужно сделать числитель 0
по делу 20
. Мы можем сделать это, вычитая:
(20 - 20) / 100
однако это не работает для 100
больше, потому что:
(100 - 20) / 100
не дает нам 100%
. Опять же, мы можем исправить это, вычитая из знаменателя как хорошо:
(100 - 20) / (100 - 20)
более обобщенное уравнение для выяснения того, что % x
лежит в диапазоне будет такой:
(x - MIN) / (MAX - MIN)
диапазон масштабирования в другой диапазон
теперь, когда мы знаем, какой процент числа лежит в диапазоне, мы можем применить его для отображения числа в другой диапазон. Давайте рассмотрим пример.
old range = [200, 1000]
new range = [10, 20]
если у нас есть число в старом диапазоне, какое число будет в новом диапазоне? Допустим, число 400
. Первый, выясните, какой процент 400
находится в пределах старого диапазона. Мы можем применить наше уравнение выше.
(400 - 200) / (1000 - 200) = 0.25
и 400
находится в 25%
старого диапазона. Нам просто нужно выяснить, какое число 25%
новой серии. Подумай о чем!--18--> of [0, 20]
есть. Это было бы 10
верно? Как вы пришли к такому ответу? Ну, мы можем просто сделать:
20 * 0.5 = 10
а, а [10, 20]
? Нам нужно сдвинуть все на 10
сейчас. например:
((20 - 10) * 0.5) + 10
более обобщенной формулой было бы:
((MAX - MIN) * PERCENT) + MIN
к первоначальному примеру чего 25%
of [10, 20]
- это:
((20 - 10) * 0.25) + 10 = 12.5
и 400
в ассортименте [200, 1000]
будет использовать 12.5
в ассортименте [10, 20]
TLDR
на карте x
от старого диапазона к новому диапазону:
OLD PERCENT = (x - OLD MIN) / (OLD MAX - OLD MIN)
NEW X = ((NEW MAX - NEW MIN) * OLD PERCENT) + NEW MIN
Я взял ответ Irritate и переработал его, чтобы свести к минимуму вычислительные шаги для последующих вычислений, разложив его на наименьшее количество констант. Мотивация заключается в том, чтобы позволить обучать скалер одному набору данных, а затем запускать новые данные (для ML algo). По сути, это очень похоже на предварительную обработку Scikit MinMaxScaler для Python в использовании.
таким образом, x' = (b-a)(x-min)/(max-min) + a
(где b!=а) становится x' = x(b-a)/(max-min) + min(-b+a)/(max-min) + a
который можно уменьшить до двух констант в виде x' = x*Part1 + Part2
.
вот реализация C# с двумя конструкторами: один для обучения и один для перезагрузки обученного экземпляра (например, для поддержки персистентности).
public class MinMaxColumnSpec
{
/// <summary>
/// To reduce repetitive computations, the min-max formula has been refactored so that the portions that remain constant are just computed once.
/// This transforms the forumula from
/// x' = (b-a)(x-min)/(max-min) + a
/// into x' = x(b-a)/(max-min) + min(-b+a)/(max-min) + a
/// which can be further factored into
/// x' = x*Part1 + Part2
/// </summary>
public readonly double Part1, Part2;
/// <summary>
/// Use this ctor to train a new scaler.
/// </summary>
public MinMaxColumnSpec(double[] columnValues, int newMin = 0, int newMax = 1)
{
if (newMax <= newMin)
throw new ArgumentOutOfRangeException("newMax", "newMax must be greater than newMin");
var oldMax = columnValues.Max();
var oldMin = columnValues.Min();
Part1 = (newMax - newMin) / (oldMax - oldMin);
Part2 = newMin + (oldMin * (newMin - newMax) / (oldMax - oldMin));
}
/// <summary>
/// Use this ctor for previously-trained scalers with known constants.
/// </summary>
public MinMaxColumnSpec(double part1, double part2)
{
Part1 = part1;
Part2 = part2;
}
public double Scale(double x) => (x * Part1) + Part2;
}