Ich versuche also herauszufinden, wie man einen Zahlenbereich nimmt und die Werte verkleinert, um sie an einen Bereich anzupassen. Der Grund dafür ist, dass ich versuche, Ellipsen in einem Java Swing Jpanel zu zeichnen. Ich möchte, dass die Höhe und Breite jeder Ellipse in einem Bereich von beispielsweise 1 bis 30 liegt. Ich habe Methoden, die die Minimal- und Maximalwerte aus meinem Datensatz ermitteln, aber ich habe die Min- und Maximalwerte erst zur Laufzeit. Gibt es eine einfache Möglichkeit, dies zu tun?

Angenommen, Sie möchten einen Bereich [min,max]auf skalieren [a,b]. Sie suchen eine (kontinuierliche) Funktion, die erfüllt

f(min) = a
f(max) = b

In Ihrem Fall awäre 1 und b30, aber beginnen wir mit etwas Einfacherem und versuchen, [min,max]den Bereich abzubilden [0,1].

Das Setzen mineiner Funktion und das Herausholen von 0 könnte mit erreicht werden

f(x) = x - min   ===>   f(min) = min - min = 0

Das ist fast das, was wir wollen. Aber das Einfügen maxwürde uns geben, max - minwann wir tatsächlich wollen 1. Also müssen wir es skalieren:

        x - min                                  max - min
f(x) = ---------   ===>   f(min) = 0;  f(max) =  --------- = 1
       max - min                                 max - min

Welches ist, was wir wollen. Wir müssen also eine Übersetzung und eine Skalierung durchführen. Wenn wir stattdessen willkürliche Werte von aund erhalten wollen b, brauchen wir etwas Komplizierteres:

       (b-a)(x - min)
f(x) = --------------  + a
          max - min

Sie können sicherstellen , dass bei der Umsetzung minfür xjetzt gibt a, und setzen in maxgibt b.

Möglicherweise stellen Sie auch fest, dass dies (b-a)/(max-min)ein Skalierungsfaktor zwischen der Größe des neuen Bereichs und der Größe des ursprünglichen Bereichs ist. Wir übersetzen also wirklich zuerst, xindem wir -mines auf den richtigen Faktor skalieren und dann wieder auf den neuen Mindestwert von übersetzen a.

Hoffe das hilft.

Hier ist etwas JavaScript zum einfachen Kopieren und Einfügen (dies ist die Antwort von irritate):

function scaleBetween(unscaledNum, minAllowed, maxAllowed, min, max) {
  return (maxAllowed - minAllowed) * (unscaledNum - min) / (max - min) + minAllowed;
}

Wird so angewendet und skaliert den Bereich 10-50 auf einen Bereich zwischen 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

Bearbeiten:

Ich weiß, dass ich das vor langer Zeit beantwortet habe, aber hier ist eine sauberere Funktion, die ich jetzt benutze:

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);
}

So angewendet:

[-4, 0, 5, 6, 9].scaleBetween(0, 100);

[0, 30.76923076923077, 69.23076923076923, 76.92307692307692, 100]

Der Einfachheit halber ist hier der Irritate-Algorithmus in einer Java-Form. Fügen Sie nach Bedarf Fehlerprüfung, Ausnahmebehandlung und Optimierung hinzu.

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;
    }
}

Prüfer:

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

So verstehe ich es:

Wie viel Prozent xliegen in einem Bereich ?

Nehmen wir an, Sie haben einen Bereich von 0bis 100. In welchem ​​"Prozent" aus diesem Bereich liegt eine beliebige Zahl aus diesem Bereich? Dies sollte ziemlich einfach sein, 0wäre 0%, 50wäre 50%und 100wäre 100%.

Nun, was ist, wenn Ihr Angebot war 20zu 100? Wir können nicht dieselbe Logik wie oben anwenden (durch 100 teilen), weil:

20 / 100

gibt uns nicht 0( 20sollte 0%jetzt sein). Dies sollte einfach zu beheben sein, wir müssen nur den Zähler 0für den Fall von machen 20. Wir können das tun, indem wir subtrahieren:

(20 - 20) / 100

Dies funktioniert jedoch nicht 100mehr, weil:

(100 - 20) / 100

gibt uns nicht 100%. Auch dies können wir beheben, indem wir vom Nenner abziehen:

(100 - 20) / (100 - 20)

Eine allgemeinere Gleichung, um herauszufinden, wie viel Prozent xin einem Bereich liegen, wäre:

(x - MIN) / (MAX - MIN)

Skalieren Sie den Bereich auf einen anderen Bereich

Nachdem wir nun wissen, wie viel Prozent einer Zahl in einem Bereich liegen, können wir sie anwenden, um die Zahl einem anderen Bereich zuzuordnen. Lassen Sie uns ein Beispiel durchgehen.

old range = [200, 1000]
new range = [10, 20]

Wenn wir eine Nummer im alten Bereich haben, welche wäre die Nummer im neuen Bereich? Nehmen wir an, die Nummer ist 400. Stellen Sie zunächst fest, wie viel Prozent 400im alten Bereich liegen. Wir können unsere obige Gleichung anwenden.

(400 - 200) / (1000 - 200) = 0.25

Liegt also 400im 25%alten Bereich. Wir müssen nur herausfinden, welche Nummer 25%aus dem neuen Bereich stammt. Überlegen Sie, was 50%von [0, 20]ist. Es wäre 10richtig? Wie sind Sie zu dieser Antwort gekommen? Nun, wir können einfach tun:

20 * 0.5 = 10

Aber was ist mit von [10, 20]? Wir müssen 10jetzt alles verschieben . z.B:

((20 - 10) * 0.5) + 10

Eine allgemeinere Formel wäre:

((MAX - MIN) * PERCENT) + MIN

Zum Original Beispiel dafür , was 25%der [10, 20]ist:

((20 - 10) * 0.25) + 10 = 12.5

Also, 400in der Reichweite [200, 1000]würde 12.5in der Reichweite abgebildet[10, 20]

TLDR

So ordnen Sie den xalten Bereich dem neuen Bereich zu:

OLD PERCENT = (x - OLD MIN) / (OLD MAX - OLD MIN)
NEW X = ((NEW MAX - NEW MIN) * OLD PERCENT) + NEW MIN

Ich bin auf diese Lösung gestoßen, aber das passt nicht wirklich zu meinen Bedürfnissen. Also habe ich ein bisschen im d3-Quellcode gegraben. Ich persönlich würde empfehlen, es so zu machen, wie es d3.scale tut.

Hier skalieren Sie die Domain auf den Bereich. Der Vorteil ist, dass Sie Zeichen in Ihren Zielbereich drehen können. Dies ist nützlich, da die y-Achse auf einem Computerbildschirm von oben nach unten zeigt, sodass große Werte ein kleines y haben.

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));
    }
}

Und hier ist der Test, bei dem Sie sehen können, was ich meine

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);
    }
}

Ich habe die Antwort von Irritate genommen und überarbeitet, um die Rechenschritte für nachfolgende Berechnungen zu minimieren, indem ich sie in die wenigsten Konstanten zerlege. Die Motivation besteht darin, einem Scaler zu ermöglichen, an einem Datensatz zu trainieren und dann mit neuen Daten (für ein ML-Algo) ausgeführt zu werden. Tatsächlich ähnelt es SciKits Vorverarbeitung von MinMaxScaler für Python in der Verwendung.

Somit wird x' = (b-a)(x-min)/(max-min) + a(wobei b! = A), x' = x(b-a)/(max-min) + min(-b+a)/(max-min) + awas in der Form auf zwei Konstanten reduziert werden kann x' = x*Part1 + Part2.

Hier ist eine C # -Implementierung mit zwei Konstruktoren: einer zum Trainieren und einer zum erneuten Laden einer trainierten Instanz (z. B. zur Unterstützung der Persistenz).

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;
}

Basierend auf der Antwort von Charles Clayton habe ich einige JSDoc- und ES6-Optimierungen aufgenommen und Vorschläge aus den Kommentaren in die ursprüngliche Antwort aufgenommen.

/**
 * Returns a scaled number within its source bounds to the desired target bounds.
 * @param {number} n - Unscaled number
 * @param {number} tMin - Minimum (target) bound to scale to
 * @param {number} tMax - Maximum (target) bound to scale to
 * @param {number} sMin - Minimum (source) bound to scale from
 * @param {number} sMax - Maximum (source) bound to scale from
 * @returns {number} The scaled number within the target bounds.
 */
const scaleBetween = (n, tMin, tMax, sMin, sMax) => {
  return (tMax - tMin) * (n - sMin) / (sMax - sMin) + tMin;
}

if (Array.prototype.scaleBetween === undefined) {
  /**
   * Returns a scaled array of numbers fit to the desired target bounds.
   * @param {number} tMin - Minimum (target) bound to scale to
   * @param {number} tMax - Maximum (target) bound to scale to
   * @returns {number} The scaled array.
   */
  Array.prototype.scaleBetween = function(tMin, tMax) {
    if (arguments.length === 1 || tMax === undefined) {
      tMax = tMin; tMin = 0;
    }
    let sMax = Math.max(...this), sMin = Math.min(...this);
    if (sMax - sMin == 0) return this.map(num => (tMin + tMax) / 2);
    return this.map(num => (tMax - tMin) * (num - sMin) / (sMax - sMin) + tMin);
  }
}

// ================================================================
// Usage
// ================================================================

let nums = [10, 13, 25, 28, 43, 50], tMin = 0, tMax = 100,
    sMin = Math.min(...nums), sMax = Math.max(...nums);

// Result: [ 0.0, 7.50, 37.50, 45.00, 82.50, 100.00 ]
console.log(nums.map(n => scaleBetween(n, tMin, tMax, sMin, sMax).toFixed(2)).join(', '));

// Result: [ 0, 30.769, 69.231, 76.923, 100 ]
console.log([-4, 0, 5, 6, 9].scaleBetween(0, 100).join(', '));

// Result: [ 50, 50, 50 ]
console.log([1, 1, 1].scaleBetween(0, 100).join(', '));

.as-console-wrapper { top: 0; max-height: 100% !important; }