Il est GARANTI de faire correspondre N'IMPORTE QUELLE gamme à N'IMPORTE QUELLE gamme.
J'ai écrit cette méthode, qui suit précisément la formule algébrique permettant de faire passer un nombre d'un intervalle à un autre. Les calculs sont effectués avec des doubles pour maintenir la précision, et à la fin, la méthode renvoie un double avec le nombre de décimales que vous avez spécifié dans les arguments de la méthode.
Il n'est pas nécessaire de nommer la limite inférieure et la limite supérieure d'un intervalle en tant que faible o élevé parce qu'il est indifférent que l'une des extrémités soit plus basse ou plus haute que l'autre extrémité de l'une ou l'autre des plages, la méthode permettra toujours d'établir correctement la carte du nombre.
Par exemple, si vous indiquez un intervalle comme étant [-100 à 300] ou [300 à -100], cela ne fera aucune différence. Le remappage sera toujours précis.
Voici comment utiliser la méthode dans votre code :
mapOneRangeToAnother(myNumber, fromRangeA, fromRangeB, toRangeA, toRangeB, decimalPrecision)
Voici un exemple d'utilisation de la méthode :
Plage de la source : -400 à 800
Plage de destination : 10000 à 3500
Numéro à re-cartographier : 250
double sourceA = -400;
double sourceB = 800;
double destA = 10000;
double destB = 3500;
double myNum = 250;
double newNum = mapOneRangeToAnother(myNum,sourceA,sourceB,destA,destB,2);
Result: 6479.17
Et si vous avez besoin d'un entier en retour, il suffit de passer 0 décimale pour la précision et de convertir le résultat en int comme ceci :
int myResult = (int) mapOneRangeToAnother(myNumber, 500, 200, -350, -125, 0);
Vous pouvez également déclarer que la méthode renvoie un int et supprimer l'élément précision décimale puis remplacer les deux dernières lignes par :
int calcScale = (int) Math.pow(10, 0);
return (int) Math.round(finalNumber * calcScale) / calcScale;
Dans la question du PO, ils utiliseraient la fonction comme suit :
int myResult = (int) mapOneRangeToAnother(input, input_start, input_end, output_start, output_end, 0);
et voici la méthode :
public static double mapOneRangeToAnother(double sourceNumber, double fromA, double fromB, double toA, double toB, int decimalPrecision ) {
double deltaA = fromB - fromA;
double deltaB = toB - toA;
double scale = deltaB / deltaA;
double negA = -1 * fromA;
double offset = (negA * scale) + toA;
double finalNumber = (sourceNumber * scale) + offset;
int calcScale = (int) Math.pow(10, decimalPrecision);
return (double) Math.round(finalNumber * calcScale) / calcScale;
}
Dans mon cas d'utilisation, j'avais besoin d'estomper l'opacité d'un contrôle JavaFX, mais comme l'opacité est un nombre de 0 à 1, j'ai simplement utilisé la méthode pour remapper l'intervalle de 1 à 100 (basé sur une boucle for qui incrémentait un int de 0 à 100) à l'intervalle de 0 à 1 et cela a fonctionné parfaitement.
Je sais maintenant que j'aurais pu créer ma boucle en changeant l'incrément de 1 à quelque chose comme 0,01, comme ceci :
for(double x=0; x<=1; x+=.01 {
//Code to change controls opacity
}
- Je l'ai juste signalé pour ceux qui pourraient faire quelque chose de similaire à ce que je faisais. La méthode fonctionne parfaitement comme décrit.
-)
