diff --git a/README.md b/README.md index 3f739b14b..60bfdc344 100644 --- a/README.md +++ b/README.md @@ -2825,19 +2825,31 @@ distance(1, 1, 2, 3); // 2.23606797749979 ### elo -Computes the new ratings between two opponents using the [Elo rating system](https://en.wikipedia.org/wiki/Elo_rating_system). It takes an array -of two pre-ratings and returns an array containing two post-ratings. -The winner's rating is the first element of the array. +Computes the new ratings between two or more opponents using the [Elo rating system](https://en.wikipedia.org/wiki/Elo_rating_system). It takes an array +of pre-ratings and returns an array containing post-ratings. +The array should be ordered from best performer to worst performer (winner -> loser). Use the exponent `**` operator and math operators to compute the expected score (chance of winning) -of each opponent and compute the new rating for each. Omit the second argument to use the default -K-factor of 32, or supply a custom K-factor value. +of each opponent and compute the new rating for each. Loop through the ratings, using each permutation to compute the post-Elo rating for each player in a pairwise fashion. Omit the second argument to use the default K-factor of 32, or supply a custom K-factor value. For details on the third argument, see the last example. ```js -const elo = ([a, b], kFactor = 32) => { +const elo = ([...ratings], kFactor = 32, selfRating) => { + const [a, b] = ratings; const expectedScore = (self, opponent) => 1 / (1 + 10 ** ((opponent - self) / 400)); - const newRating = (rating, i) => rating + kFactor * (i - expectedScore(i ? a : b, i ? b : a)); - return [newRating(a, 1), newRating(b, 0)]; + const newRating = (rating, i) => + (selfRating || rating) + kFactor * (i - expectedScore(i ? a : b, i ? b : a)); + if (ratings.length === 2) { + return [newRating(a, 1), newRating(b, 0)]; + } else { + for (let i = 0; i < ratings.length; i++) { + let j = i; + while (j < ratings.length - 1) { + [ratings[i], ratings[j + 1]] = elo([ratings[i], ratings[j + 1]], kFactor); + j++; + } + } + } + return ratings; }; ``` @@ -2845,8 +2857,16 @@ const elo = ([a, b], kFactor = 32) => { Examples ```js +// Standard 1v1s elo([1200, 1200]); // [1216, 1184] elo([1200, 1200], 64); // [1232, 1168] +// 4 player FFA, all same rank +elo([1200, 1200, 1200, 1200]).map(Math.round); // [1246, 1215, 1185, 1154] +/* +For teams, each rating can adjusted based on own team's average rating vs. +average rating of opposing team, with the score being added to their +own individual rating by supplying it as the third argument. +*/ ``` diff --git a/docs/index.html b/docs/index.html index c43162cc5..b63e3cf33 100644 --- a/docs/index.html +++ b/docs/index.html @@ -569,13 +569,34 @@ document.bodyShow examples
digitize(123); // [1, 2, 3]

distance

Returns the distance between two points.

Use Math.hypot() to calculate the Euclidean distance between two points.

const distance = (x0, y0, x1, y1) => Math.hypot(x1 - x0, y1 - y0);
 
distance(1, 1, 2, 3); // 2.23606797749979
-

elo

Computes the new ratings between two opponents using the Elo rating system. It takes an array of two pre-ratings and returns an array containing two post-ratings. The winner's rating is the first element of the array.

Use the exponent ** operator and math operators to compute the expected score (chance of winning) of each opponent and compute the new rating for each. Omit the second argument to use the default K-factor of 32, or supply a custom K-factor value.

const elo = ([a, b], kFactor = 32) => {
+

elo

Computes the new ratings between two or more opponents using the Elo rating system. It takes an array of pre-ratings and returns an array containing post-ratings. The array should be ordered from best performer to worst performer (winner -> loser).

Use the exponent ** operator and math operators to compute the expected score (chance of winning) of each opponent and compute the new rating for each. Loop through the ratings, using each permutation to compute the post-Elo rating for each player in a pairwise fashion. Omit the second argument to use the default K-factor of 32, or supply a custom K-factor value. For details on the third argument, see the last example.

const elo = ([...ratings], kFactor = 32, selfRating) => {
+  const [a, b] = ratings;
   const expectedScore = (self, opponent) => 1 / (1 + 10 ** ((opponent - self) / 400));
-  const newRating = (rating, i) => rating + kFactor * (i - expectedScore(i ? a : b, i ? b : a));
-  return [newRating(a, 1), newRating(b, 0)];
+  const newRating = (rating, i) =>
+    (selfRating || rating) + kFactor * (i - expectedScore(i ? a : b, i ? b : a));
+  if (ratings.length === 2) {
+    return [newRating(a, 1), newRating(b, 0)];
+  } else {
+    for (let i = 0; i < ratings.length; i++) {
+      let j = i;
+      while (j < ratings.length - 1) {
+        [ratings[i], ratings[j + 1]] = elo([ratings[i], ratings[j + 1]], kFactor);
+        j++;
+      }
+    }
+  }
+  return ratings;
 };
-
elo([1200, 1200]); // [1216, 1184]
+
// Standard 1v1s
+elo([1200, 1200]); // [1216, 1184]
 elo([1200, 1200], 64); // [1232, 1168]
+// 4 player FFA, all same rank
+elo([1200, 1200, 1200, 1200]).map(Math.round); // [1246, 1215, 1185, 1154]
+/*
+For teams, each rating can adjusted based on own team's average rating vs. 
+average rating of opposing team, with the score being added to their
+own individual rating by supplying it as the third argument.
+*/

factorial

Calculates the factorial of a number.

Use recursion. If n is less than or equal to 1, return 1. Otherwise, return the product of n and the factorial of n - 1. Throws an exception if n is a negative number.

const factorial = n =>
   n < 0
     ? (() => {