La fonction de normaliser n'importe quel nombre de 0 - 1

Je suis en train de faire une fonction qui prend un nombre et normalise de 0 - 1 entre min et max de limites. Par exemple:

Si je veux normaliser une valeur de 10 entre 5 à 15, j'appelle cela:

val = 10; normalize(val, 5, 15); Renvoie à 0,5

normaliser une valeur entre 0 -10 et 5

val = 0; normalize(val, -10, 5); Retourne 0.666

C'est la fonction que je suis venu avec:

function normalize(val, min, max){
  //Shift to positive to avoid issues when crossing the 0 line
  if(min < 0){
    max += 0 - min;
    val += 0 - min;
    min = 0;
  }
  //Shift values from 0 - max
  val = val - min;
  max = max - min;
  return Math.max(0, Math.min(1, val / max));
}

Ma question est: Est-ce la méthode la plus efficace pour normaliser une 1-dimensions de la valeur? Je vais être l'appel de cette fonction quelques milliers de fois par trame à 60fps, donc je voudrais l'avoir optimisé que possible afin de réduire la charge de calcul. J'ai regardé pour la normalisation des formules, mais tout ce que je trouve sont à 2 ou 3 dimensions solutions.

Je ne vois pas la raison pour laquelle vous traitez négatif minutes séparément,
est min et max, toujours le même pour le tableau?
Wow, vous avez raison! J'ai été préventivement le faire sans vraiment le tester. Il fonctionne sans changer de vitesse > 0
min et max serait de changer selon l'endroit où je suis en l'appelant. Parfois, il sera -100, 0 parfois -3, 781, etc.
Il suffit donc de retirer la gestion spéciale de négatif min et vous êtes bon pour aller.

OriginalL'auteur Marquizzo | 2016-09-29

  1. 29

    Pourquoi ne pas simplement:

    function(val, max, min) { return (val - min) /(max - min); }

    Excellent, merci! Cela semble être la façon la plus simple. J'ai été de compliquer à l'excès des choses avec l'instruction if. Cependant, j'ai encore envie de serrer les valeurs entre 0 et 1, donc je pense que je vais faire return Math.max(0, Math.min(1, val-min / max-min))
    Aussi longtemps que val est en fait entre min et max le résultat sera toujours entre 0 et 1.
    Je sais. Le truc, c'est que val ne sera pas toujours entre min et max, j'ai donc besoin d'un moyen de l'empêcher de revenir nombres négatifs ou quoi que ce soit au-dessus de 1
    N'oubliez pas de mettre des parenthèses autour de (max-min).

    OriginalL'auteur Nathan Berton

  2. 3

    À l'aide de Nathan Bertons's réponse, vous devez valider si max-min est égale à zéro, sinon le retour sera NaN:

    function (val, max, min) {
    if(max - min === 0) return 1 //or 0, it's up to you
    return (val - min) /(max - min);
    }

    et vous pouvez utiliser un la généralisation pour limiter la plage de valeurs dans le jeu de données entre l'arbitraire des points a et b à l'aide de:

    function (val, max, min) {
    if(max - min === 0) return 1 //or 0, it's up to you
    return a + (((val - min) * (b-a)) /(max - min));
    }

    max - min sera égal à zéro si ils ont la même valeur, il n'y a pas moyen de donner max = 5 et min = 5.

    OriginalL'auteur Pedro Diniz

  3. -1

    Je Vais compléter la réponse de Nina Scholz, vous pouvez utiliser le trait de soulignement de la bibliothèque pour trouver le minimum et le maximum pour tableau et vous pouvez l'utiliser comme suivent, ou créer votre propre (méthodes simples avec une simple boucle):

    si vous utilisez nodeJS vous devez installer le trait de soulignement avec la commande npm install trait de soulignement et de l'utiliser avec la commande
    var _ = require('underscore/underscore');
    ou vous pouvez importer la bibliothèque sur le code html et utiliser sur votre site web

    

    function min(arr) {
        if (!arr.length) return null;
        var minValue = arr[0];
        for (var item of arr) {
            if (item  maxValue) maxValue = item;
        }
        return maxValue;
    }

    var array = [1, 2, 3, 4, 5, 6, 7, 8, 9];

    function normalize(min, max) {
        var delta = max - min;
        return function (val) {
            return (val - min) / delta;
        };
    }

    function normalizeArray(array) {
        var minValue = min(array); //if you use underscore _.min(array)
        var maxValue = max(array);//if you use underscore _.max(array)
        return array.map(normalize(minValue, maxValue));
    }
    console.log(normalizeArray(array));
    twitter.com/sarah_edo/status/961003320616697856
    Désolé, ici vous trouverez également la fonction max 🙂 la fonction max(arr) { if (!arr.length) return null; var maxValue = arr[0]; for (var point d'arr) { if (item > maxValue) maxValue = item; } return maxValue; }

    OriginalL'auteur Naim Sulejmani