Ecosyste.ms: Awesome
An open API service indexing awesome lists of open source software.
https://github.com/alcalyn/elo
Elo system with a reliability purpose
https://github.com/alcalyn/elo
Last synced: 12 days ago
JSON representation
Elo system with a reliability purpose
- Host: GitHub
- URL: https://github.com/alcalyn/elo
- Owner: alcalyn
- License: mit
- Created: 2014-11-25T09:16:51.000Z (almost 10 years ago)
- Default Branch: master
- Last Pushed: 2016-11-07T17:36:00.000Z (about 8 years ago)
- Last Synced: 2024-10-11T13:12:28.997Z (28 days ago)
- Language: PHP
- Size: 12.7 KB
- Stars: 6
- Watchers: 3
- Forks: 1
- Open Issues: 0
-
Metadata Files:
- Readme: README.md
- License: LICENSE
Awesome Lists containing this project
README
Elo system
==========
Another **Elo** implementation in **PHP** ! But this one introduce a **reliability** purpose.
[](https://scrutinizer-ci.com/g/alcalyn/elo/?branch=master)
[](https://travis-ci.org/alcalyn/elo)
[](https://packagist.org/packages/alcalyn/elo)
## Reliability purpose
**A history**: You have a good player **A** which played many games and have a score of **2100 Elo**.
A new player **B** subscribe to the game website, so his Elo score is initialized to **1500**.
But in fact, he is a very good player, better than **A**, and beat him like crushing an ant.
**The problem**: New player **B** will win many Elo because he won against a **2100 Elo** player. That's ok.
But player **A** (**2100 Elo**) will lose many Elo because he lost against a **1500 Elo** player, but in fact strongest.
The fact is that the **new player Elo score is not reliable**, so it should not impact others players Elo scores.
**The solution**: This library. It introduces a **reliability coefficient** (decimal between 0.0 and 1.0) for Elo A and Elo B.
## Composer
Install via composer
``` js
{
"require": {
"alcalyn/elo": "1.x"
}
}
```
*Or download the library manually if you don't use composer.*
## Usage
- Instantiate a standard Elo system
``` php
use Alcalyn/Elo/EloSystem;
$eloSystem = new EloSystem();
```
- Calculate updated Elo scores from old Elo
``` php
/**
* A player with 1650 Elo beat another with 1920
*/
$updatedElos = $eloSystem->calculate(1650, 1920, 1);
print_r($updatedElos);
/* Output:
Array
(
[0] => 1663.2084157978
[1] => 1906.7915842022
)
*/
```
- Set **reliability** coefficient to Elo scores
``` php
/**
* A player with 1907 Elo (1.0 reliability)
* lose against a new player with 1500 (and reliability to 0.0)
*/
$updatedElos = $eloSystem->calculate(1907, 1500, 0, 1.0, 0.0);
print_r($updatedElos);
/* Output:
Array
(
[0] => 1907
[1] => 1514.5978664353
)
*/
```
- Using method aliases for win, lose or draw
``` php
/**
* Method Aliases
*/
$elo->win(2100, 1500, 1.0, 0.0);
$elo->lose(2100, 1500, 1.0, 0.0);
$elo->draw(2100, 1500, 1.0, 0.0);
```
- Instanciate a system with a different K factor (default is 16)
``` php
/**
* Use a different K factor in your Elo system
*/
$eloSystemK32 = new EloSystem(32);
```
## Detailled examples
**A new player**:
Player **A** has **2100 Elo**, reliability **1.0**
Player **B** has **1500 Elo**, reliability **0.0**
**A** wins: Expected result, so **B** loses a small amount of Elo, and **A** win nothing.
**B** wins: NOT expected result, so **B** wins a BIG amount of Elo, and **A** lose nothing.
**A** Elo score will not be updated when he plays versus a new player with an unreliable Elo score.
(*And new player* ***B*** *should have its Elo reliability increased by something like 1/10
after every games until his reliability reaches 1*)
``` php
$elo = new EloSystem();
/**
* Result without reliability
*/
print_r($elo->lose(2100, 1500));
/* Output:
Array
(
[0] => 2084.4904548805 // lose -16 Elo
[1] => 1515.5095451195 // win +16 Elo
)
*/
/**
* Result with reliability
*/
print_r($elo->lose(2100, 1500, 1.0, 0.0));
/* Output:
Array
(
[0] => 2100 // don't lose Elo against new player
[1] => 1515.5095451195 // win +16 Elo vs reliable Elo score
)
*/
```
**Another example: two newbies players**:
Player **A** has **1500 Elo**, reliability **0.0**
Player **B** has **1500 Elo**, reliability **0.0**
There is two new players, so their reliabilities are both 0.0:
**the algorithm takes them like if they were both 1.0**.
And if player **A** had an Elo reliability equal to **0.4**, and player **B** equal to **0.0**,
the algorithm adds them **+0.6** so one of reliabilities reaches **1.0**.
## License
This project is under [MIT Lisense](https://github.com/alcalyn/elo/blob/master/LICENSE)