@xcpcio/core 0.45.1 → 0.46.0

package/dist/index.cjs

@@ -576,6 +576,233 @@ function getWhiteOrBlackColor(background) {
   return brightness <= threshold ? "#fff" : "#000";
 }
 
+class RatingHistory {
+  constructor() {
+    this.rank = 0;
+    this.rating = 0;
+    this.contestID = "";
+    this.contestName = "";
+    this.contestLink = "";
+    this.contestTime = createDayJS();
+  }
+  toJSON() {
+    return {
+      rank: this.rank,
+      rating: this.rating,
+      contestID: this.contestID,
+      contestName: this.contestName,
+      contestLink: this.contestLink,
+      contestTime: this.contestTime.toDate()
+    };
+  }
+  static fromJSON(iRatingHistory) {
+    if (typeof iRatingHistory === "string") {
+      iRatingHistory = JSON.parse(iRatingHistory);
+    }
+    const ratingHistory = new RatingHistory();
+    ratingHistory.rank = iRatingHistory.rank;
+    ratingHistory.rating = iRatingHistory.rating;
+    ratingHistory.contestID = iRatingHistory.contestID;
+    ratingHistory.contestName = iRatingHistory.contestName;
+    ratingHistory.contestLink = iRatingHistory.contestLink;
+    ratingHistory.contestTime = createDayJS(iRatingHistory.contestTime);
+    return ratingHistory;
+  }
+}
+
+class RatingUser {
+  constructor() {
+    this.id = "";
+    this.name = "";
+    this.rating = 0;
+    this.minRating = 1061109567;
+    this.maxRating = -1061109567;
+    this.rank = 0;
+    this.oldRating = 0;
+    this.seed = 1;
+    this.delta = 0;
+    this.ratingHistories = [];
+  }
+  UpdateRating(rating) {
+    this.rating = rating;
+    this.minRating = Math.min(this.minRating, rating);
+    this.maxRating = Math.max(this.maxRating, rating);
+  }
+  toJSON() {
+    return {
+      id: this.id,
+      name: this.name,
+      rating: this.rating,
+      minRating: this.minRating,
+      maxRating: this.maxRating,
+      ratingHistories: this.ratingHistories.map((ratingHistory) => ratingHistory.toJSON())
+    };
+  }
+  static fromJSON(iRatingUser) {
+    if (typeof iRatingUser === "string") {
+      iRatingUser = JSON.parse(iRatingUser);
+    }
+    const ratingUser = new RatingUser();
+    ratingUser.id = iRatingUser.id;
+    ratingUser.name = iRatingUser.name;
+    ratingUser.rating = iRatingUser.rating;
+    ratingUser.minRating = iRatingUser.minRating;
+    ratingUser.maxRating = iRatingUser.maxRating;
+    for (const iRatingHistory of iRatingUser.ratingHistories) {
+      ratingUser.ratingHistories.push(RatingHistory.fromJSON(iRatingHistory));
+    }
+    return ratingUser;
+  }
+}
+
+class RatingCalculator {
+  constructor() {
+    this.users = [];
+  }
+  calculate() {
+    this.calculateInternal();
+  }
+  calcP(userA, userB) {
+    return 1 / (1 + 10 ** ((userB.oldRating - userA.oldRating) / 400));
+  }
+  getExSeed(users, rating, ownUser) {
+    const exUser = new RatingUser();
+    exUser.oldRating = rating;
+    let res = 0;
+    users.forEach((user) => {
+      if (user.id !== ownUser.id) {
+        res += this.calcP(user, exUser);
+      }
+    });
+    return res;
+  }
+  calcRating(users, rank, user) {
+    let left = 1;
+    let right = 8e3;
+    while (right - left > 1) {
+      const mid = Math.floor((left + right) / 2);
+      if (this.getExSeed(users, mid, user) < rank) {
+        right = mid;
+      } else {
+        left = mid;
+      }
+    }
+    return left;
+  }
+  calculateInternal() {
+    for (let i = 0; i < this.users.length; i++) {
+      const u = this.users[i];
+      u.seed = 1;
+      for (let j = 0; j < this.users.length; j++) {
+        if (i !== j) {
+          const otherUser = this.users[j];
+          u.seed += this.calcP(otherUser, u);
+        }
+      }
+    }
+    let sumDelta = 0;
+    for (let i = 0; i < this.users.length; i++) {
+      const u = this.users[i];
+      u.delta = Math.floor(
+        (this.calcRating(this.users, Math.sqrt(u.rank * u.seed), u) - u.oldRating) / 2
+      );
+      sumDelta += u.delta;
+    }
+    let inc = Math.floor(-sumDelta / this.users.length) - 1;
+    for (let i = 0; i < this.users.length; i++) {
+      const u = this.users[i];
+      u.delta += inc;
+    }
+    this.users = this.users.sort((a, b) => b.oldRating - a.oldRating);
+    const s = Math.min(this.users.length, Math.floor(4 * Math.round(Math.sqrt(this.users.length))));
+    let sumS = 0;
+    for (let i = 0; i < s; i++) {
+      sumS += this.users[i].delta;
+    }
+    inc = Math.min(Math.max(Math.floor(-sumS / s), -10), 0);
+    this.users.forEach((u) => {
+      u.delta += inc;
+      u.UpdateRating(u.oldRating + u.delta);
+    });
+    this.users = this.users.sort((a, b) => a.rank - b.rank);
+  }
+}
+
+class Rating {
+  constructor() {
+    this.id = "";
+    this.name = "";
+    this.baseRating = 1500;
+    this.contestIDs = [];
+    this.users = [];
+    this.ranks = [];
+    this.userMap = /* @__PURE__ */ new Map();
+  }
+  buildRating() {
+    for (const rank of this.ranks) {
+      rank.buildRank();
+      for (const u of this.users) {
+        u.oldRating = u.rating;
+      }
+      for (const t of rank.teams) {
+        const id = this.generateTeamId(t);
+        if (!this.userMap.has(id)) {
+          const u = new RatingUser();
+          u.id = id;
+          u.name = t.name;
+          u.rank = t.rank;
+          u.oldRating = this.baseRating;
+          u.UpdateRating(this.baseRating);
+          this.userMap.set(id, u);
+          this.users.push(u);
+        }
+      }
+      const ratingCalculator = new RatingCalculator();
+      ratingCalculator.users = this.users;
+      ratingCalculator.calculate();
+      for (const u of this.users) {
+        const h = new RatingHistory();
+        h.rank = u.rank;
+        h.rating = u.rating;
+        h.contestID = rank.contest.id;
+        h.contestLink = h.contestID;
+        h.contestName = rank.contest.name;
+        h.contestTime = rank.contest.startTime;
+        u.ratingHistories.push(h);
+      }
+    }
+  }
+  generateTeamId(t) {
+    if (Array.isArray(t.members) && t.members.length > 0) {
+      return t.members.join("|");
+    }
+    return `${t.organization}-${t.name}`;
+  }
+  toJSON() {
+    return {
+      id: this.id,
+      name: this.name,
+      baseRating: this.baseRating,
+      contestIDs: this.contestIDs,
+      users: this.users.map((ratingUser) => ratingUser.toJSON())
+    };
+  }
+  static fromJSON(iRating) {
+    if (typeof iRating === "string") {
+      iRating = JSON.parse(iRating);
+    }
+    const rating = new Rating();
+    rating.id = iRating.id;
+    rating.name = iRating.name;
+    rating.baseRating = iRating.baseRating;
+    rating.contestIDs = iRating.contestIDs;
+    for (const iUser of iRating.users) {
+      rating.users.push(RatingUser.fromJSON(iUser));
+    }
+    return rating;
+  }
+}
+
 class ProblemStatistics {
   constructor() {
     this.acceptedNum = 0;
@@ -1183,6 +1410,7 @@ function createContestOptions(contestOptionsJSON = {}) {
 
 class Contest {
   constructor() {
+    this.id = "";
     this.name = "";
     this.startTime = createDayJS();
     this.endTime = createDayJS();
@@ -2042,6 +2270,10 @@ exports.ProblemStatistics = ProblemStatistics;
 exports.Rank = Rank;
 exports.RankOptions = RankOptions;
 exports.RankStatistics = RankStatistics;
+exports.Rating = Rating;
+exports.RatingCalculator = RatingCalculator;
+exports.RatingHistory = RatingHistory;
+exports.RatingUser = RatingUser;
 exports.Resolver = Resolver;
 exports.Submission = Submission;
 exports.Team = Team;

package/dist/index.d.ts

@@ -1,7 +1,8 @@
-import { TimeUnit, SubmissionStatus, Submission as Submission$1, Submissions as Submissions$1, BalloonColor, Problem as Problem$1, Problems as Problems$1, Lang, CalculationOfPenalty, StatusTimeDisplay, MedalPreset, Image, BannerMode, ContestState, Contest as Contest$1, Team as Team$1, Teams as Teams$1, ContestIndex as ContestIndex$1 } from '@xcpcio/types';
+import { TimeUnit, SubmissionStatus, Submission as Submission$1, Submissions as Submissions$1, BalloonColor, Problem as Problem$1, Problems as Problems$1, Lang, CalculationOfPenalty, StatusTimeDisplay, MedalPreset, Image, BannerMode, ContestState, Contest as Contest$1, Team as Team$1, Teams as Teams$1, IRatingHistory, ContestIndex as ContestIndex$1 } from '@xcpcio/types';
 import dayjs from 'dayjs';
 export { default as dayjs } from 'dayjs';
 import * as XLSX from 'xlsx-js-style';
+import { IRatingUser, IRating } from '@xcpcio/types/index';
 
 declare class Submission {
     id: string;
@@ -126,6 +127,7 @@ declare class ContestOptions {
 }
 
 declare class Contest {
+    id: string;
     name: string;
     startTime: dayjs.Dayjs;
     endTime: dayjs.Dayjs;
@@ -331,6 +333,7 @@ declare class Rank {
     buildBalloons(): void;
     setReplayTime(replayStartTimestamp: number): void;
 }
+type Ranks = Array<Rank>;
 
 declare class CodeforcesGymGhostDATConverter {
     constructor();
@@ -352,6 +355,63 @@ declare class ICPCStandingsCsvConverter {
     private getMedalCitation;
 }
 
+declare class RatingHistory {
+    rank: number;
+    rating: number;
+    contestID: string;
+    contestName: string;
+    contestLink: string;
+    contestTime: dayjs.Dayjs;
+    constructor();
+    toJSON(): IRatingHistory;
+    static fromJSON(iRatingHistory: IRatingHistory | string): RatingHistory;
+}
+type RatingHistories = Array<RatingHistory>;
+
+declare class RatingUser {
+    id: string;
+    name: string;
+    rating: number;
+    minRating: number;
+    maxRating: number;
+    rank: number;
+    oldRating: number;
+    seed: number;
+    delta: number;
+    ratingHistories: RatingHistories;
+    constructor();
+    UpdateRating(rating: number): void;
+    toJSON(): IRatingUser;
+    static fromJSON(iRatingUser: IRatingUser | string): RatingUser;
+}
+type RatingUsers = Array<RatingUser>;
+type RatingUserMap = Map<string, RatingUser>;
+
+declare class RatingCalculator {
+    users: RatingUsers;
+    constructor();
+    calculate(): void;
+    private calcP;
+    private getExSeed;
+    private calcRating;
+    private calculateInternal;
+}
+
+declare class Rating {
+    id: string;
+    name: string;
+    baseRating: number;
+    contestIDs: string[];
+    users: RatingUsers;
+    ranks: Ranks;
+    userMap: RatingUserMap;
+    constructor();
+    buildRating(): void;
+    generateTeamId(t: Team): string;
+    toJSON(): IRating;
+    static fromJSON(iRating: IRating | string): Rating;
+}
+
 declare class ContestIndexConfig {
     contestName: string;
     startTime: dayjs.Dayjs;
@@ -398,4 +458,4 @@ declare function isRejected(status: SubmissionStatus): boolean;
 declare function isPending(status: SubmissionStatus): boolean;
 declare function isNotCalculatedPenaltyStatus(status: SubmissionStatus): boolean;
 
-export { Award, Awards, Balloon, Balloons, BattleOfGiants, CodeforcesGymGhostDATConverter, Contest, ContestIndex, ContestIndexConfig, ContestIndexList, ContestOptions, GeneralExcelConverter, Giants, GiantsType, ICPCStandingsCsvConverter, MedalType, PlaceChartPointData, Problem, ProblemStatistics, Problems, Rank, RankOptions, RankStatistics, Resolver, SelectOptionItem, Submission, Submissions, Team, TeamProblemStatistics, Teams, calcDirt, createContest, createContestIndex, createContestIndexList, createDayJS, createProblem, createProblems, createProblemsByProblemIds, createSubmission, createSubmissions, createTeam, createTeams, getImageSource, getTimeDiff, getTimestamp, getWhiteOrBlackColor, getWhiteOrBlackColorV1, isAccepted, isNotCalculatedPenaltyStatus, isPending, isRejected, isValidMedalType, stringToSubmissionStatus };
+export { Award, Awards, Balloon, Balloons, BattleOfGiants, CodeforcesGymGhostDATConverter, Contest, ContestIndex, ContestIndexConfig, ContestIndexList, ContestOptions, GeneralExcelConverter, Giants, GiantsType, ICPCStandingsCsvConverter, MedalType, PlaceChartPointData, Problem, ProblemStatistics, Problems, Rank, RankOptions, RankStatistics, Ranks, Rating, RatingCalculator, RatingHistories, RatingHistory, RatingUser, RatingUserMap, RatingUsers, Resolver, SelectOptionItem, Submission, Submissions, Team, TeamProblemStatistics, Teams, calcDirt, createContest, createContestIndex, createContestIndexList, createDayJS, createProblem, createProblems, createProblemsByProblemIds, createSubmission, createSubmissions, createTeam, createTeams, getImageSource, getTimeDiff, getTimestamp, getWhiteOrBlackColor, getWhiteOrBlackColorV1, isAccepted, isNotCalculatedPenaltyStatus, isPending, isRejected, isValidMedalType, stringToSubmissionStatus };

package/dist/index.mjs

@@ -543,6 +543,233 @@ function getWhiteOrBlackColor(background) {
   return brightness <= threshold ? "#fff" : "#000";
 }
 
+class RatingHistory {
+  constructor() {
+    this.rank = 0;
+    this.rating = 0;
+    this.contestID = "";
+    this.contestName = "";
+    this.contestLink = "";
+    this.contestTime = createDayJS();
+  }
+  toJSON() {
+    return {
+      rank: this.rank,
+      rating: this.rating,
+      contestID: this.contestID,
+      contestName: this.contestName,
+      contestLink: this.contestLink,
+      contestTime: this.contestTime.toDate()
+    };
+  }
+  static fromJSON(iRatingHistory) {
+    if (typeof iRatingHistory === "string") {
+      iRatingHistory = JSON.parse(iRatingHistory);
+    }
+    const ratingHistory = new RatingHistory();
+    ratingHistory.rank = iRatingHistory.rank;
+    ratingHistory.rating = iRatingHistory.rating;
+    ratingHistory.contestID = iRatingHistory.contestID;
+    ratingHistory.contestName = iRatingHistory.contestName;
+    ratingHistory.contestLink = iRatingHistory.contestLink;
+    ratingHistory.contestTime = createDayJS(iRatingHistory.contestTime);
+    return ratingHistory;
+  }
+}
+
+class RatingUser {
+  constructor() {
+    this.id = "";
+    this.name = "";
+    this.rating = 0;
+    this.minRating = 1061109567;
+    this.maxRating = -1061109567;
+    this.rank = 0;
+    this.oldRating = 0;
+    this.seed = 1;
+    this.delta = 0;
+    this.ratingHistories = [];
+  }
+  UpdateRating(rating) {
+    this.rating = rating;
+    this.minRating = Math.min(this.minRating, rating);
+    this.maxRating = Math.max(this.maxRating, rating);
+  }
+  toJSON() {
+    return {
+      id: this.id,
+      name: this.name,
+      rating: this.rating,
+      minRating: this.minRating,
+      maxRating: this.maxRating,
+      ratingHistories: this.ratingHistories.map((ratingHistory) => ratingHistory.toJSON())
+    };
+  }
+  static fromJSON(iRatingUser) {
+    if (typeof iRatingUser === "string") {
+      iRatingUser = JSON.parse(iRatingUser);
+    }
+    const ratingUser = new RatingUser();
+    ratingUser.id = iRatingUser.id;
+    ratingUser.name = iRatingUser.name;
+    ratingUser.rating = iRatingUser.rating;
+    ratingUser.minRating = iRatingUser.minRating;
+    ratingUser.maxRating = iRatingUser.maxRating;
+    for (const iRatingHistory of iRatingUser.ratingHistories) {
+      ratingUser.ratingHistories.push(RatingHistory.fromJSON(iRatingHistory));
+    }
+    return ratingUser;
+  }
+}
+
+class RatingCalculator {
+  constructor() {
+    this.users = [];
+  }
+  calculate() {
+    this.calculateInternal();
+  }
+  calcP(userA, userB) {
+    return 1 / (1 + 10 ** ((userB.oldRating - userA.oldRating) / 400));
+  }
+  getExSeed(users, rating, ownUser) {
+    const exUser = new RatingUser();
+    exUser.oldRating = rating;
+    let res = 0;
+    users.forEach((user) => {
+      if (user.id !== ownUser.id) {
+        res += this.calcP(user, exUser);
+      }
+    });
+    return res;
+  }
+  calcRating(users, rank, user) {
+    let left = 1;
+    let right = 8e3;
+    while (right - left > 1) {
+      const mid = Math.floor((left + right) / 2);
+      if (this.getExSeed(users, mid, user) < rank) {
+        right = mid;
+      } else {
+        left = mid;
+      }
+    }
+    return left;
+  }
+  calculateInternal() {
+    for (let i = 0; i < this.users.length; i++) {
+      const u = this.users[i];
+      u.seed = 1;
+      for (let j = 0; j < this.users.length; j++) {
+        if (i !== j) {
+          const otherUser = this.users[j];
+          u.seed += this.calcP(otherUser, u);
+        }
+      }
+    }
+    let sumDelta = 0;
+    for (let i = 0; i < this.users.length; i++) {
+      const u = this.users[i];
+      u.delta = Math.floor(
+        (this.calcRating(this.users, Math.sqrt(u.rank * u.seed), u) - u.oldRating) / 2
+      );
+      sumDelta += u.delta;
+    }
+    let inc = Math.floor(-sumDelta / this.users.length) - 1;
+    for (let i = 0; i < this.users.length; i++) {
+      const u = this.users[i];
+      u.delta += inc;
+    }
+    this.users = this.users.sort((a, b) => b.oldRating - a.oldRating);
+    const s = Math.min(this.users.length, Math.floor(4 * Math.round(Math.sqrt(this.users.length))));
+    let sumS = 0;
+    for (let i = 0; i < s; i++) {
+      sumS += this.users[i].delta;
+    }
+    inc = Math.min(Math.max(Math.floor(-sumS / s), -10), 0);
+    this.users.forEach((u) => {
+      u.delta += inc;
+      u.UpdateRating(u.oldRating + u.delta);
+    });
+    this.users = this.users.sort((a, b) => a.rank - b.rank);
+  }
+}
+
+class Rating {
+  constructor() {
+    this.id = "";
+    this.name = "";
+    this.baseRating = 1500;
+    this.contestIDs = [];
+    this.users = [];
+    this.ranks = [];
+    this.userMap = /* @__PURE__ */ new Map();
+  }
+  buildRating() {
+    for (const rank of this.ranks) {
+      rank.buildRank();
+      for (const u of this.users) {
+        u.oldRating = u.rating;
+      }
+      for (const t of rank.teams) {
+        const id = this.generateTeamId(t);
+        if (!this.userMap.has(id)) {
+          const u = new RatingUser();
+          u.id = id;
+          u.name = t.name;
+          u.rank = t.rank;
+          u.oldRating = this.baseRating;
+          u.UpdateRating(this.baseRating);
+          this.userMap.set(id, u);
+          this.users.push(u);
+        }
+      }
+      const ratingCalculator = new RatingCalculator();
+      ratingCalculator.users = this.users;
+      ratingCalculator.calculate();
+      for (const u of this.users) {
+        const h = new RatingHistory();
+        h.rank = u.rank;
+        h.rating = u.rating;
+        h.contestID = rank.contest.id;
+        h.contestLink = h.contestID;
+        h.contestName = rank.contest.name;
+        h.contestTime = rank.contest.startTime;
+        u.ratingHistories.push(h);
+      }
+    }
+  }
+  generateTeamId(t) {
+    if (Array.isArray(t.members) && t.members.length > 0) {
+      return t.members.join("|");
+    }
+    return `${t.organization}-${t.name}`;
+  }
+  toJSON() {
+    return {
+      id: this.id,
+      name: this.name,
+      baseRating: this.baseRating,
+      contestIDs: this.contestIDs,
+      users: this.users.map((ratingUser) => ratingUser.toJSON())
+    };
+  }
+  static fromJSON(iRating) {
+    if (typeof iRating === "string") {
+      iRating = JSON.parse(iRating);
+    }
+    const rating = new Rating();
+    rating.id = iRating.id;
+    rating.name = iRating.name;
+    rating.baseRating = iRating.baseRating;
+    rating.contestIDs = iRating.contestIDs;
+    for (const iUser of iRating.users) {
+      rating.users.push(RatingUser.fromJSON(iUser));
+    }
+    return rating;
+  }
+}
+
 class ProblemStatistics {
   constructor() {
     this.acceptedNum = 0;
@@ -1150,6 +1377,7 @@ function createContestOptions(contestOptionsJSON = {}) {
 
 class Contest {
   constructor() {
+    this.id = "";
     this.name = "";
     this.startTime = createDayJS();
     this.endTime = createDayJS();
@@ -1989,4 +2217,4 @@ class Resolver extends Rank {
   }
 }
 
-export { Award, Balloon, BattleOfGiants, CodeforcesGymGhostDATConverter, Contest, ContestIndex, ContestIndexConfig, ContestOptions, GeneralExcelConverter, Giants, GiantsType, ICPCStandingsCsvConverter, MedalType, PlaceChartPointData, Problem, ProblemStatistics, Rank, RankOptions, RankStatistics, Resolver, Submission, Team, TeamProblemStatistics, calcDirt, createContest, createContestIndex, createContestIndexList, createDayJS, createProblem, createProblems, createProblemsByProblemIds, createSubmission, createSubmissions, createTeam, createTeams, getImageSource, getTimeDiff, getTimestamp, getWhiteOrBlackColor, getWhiteOrBlackColorV1, isAccepted, isNotCalculatedPenaltyStatus, isPending, isRejected, isValidMedalType, stringToSubmissionStatus };
+export { Award, Balloon, BattleOfGiants, CodeforcesGymGhostDATConverter, Contest, ContestIndex, ContestIndexConfig, ContestOptions, GeneralExcelConverter, Giants, GiantsType, ICPCStandingsCsvConverter, MedalType, PlaceChartPointData, Problem, ProblemStatistics, Rank, RankOptions, RankStatistics, Rating, RatingCalculator, RatingHistory, RatingUser, Resolver, Submission, Team, TeamProblemStatistics, calcDirt, createContest, createContestIndex, createContestIndexList, createDayJS, createProblem, createProblems, createProblemsByProblemIds, createSubmission, createSubmissions, createTeam, createTeams, getImageSource, getTimeDiff, getTimestamp, getWhiteOrBlackColor, getWhiteOrBlackColorV1, isAccepted, isNotCalculatedPenaltyStatus, isPending, isRejected, isValidMedalType, stringToSubmissionStatus };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xcpcio/core",
-  "version": "0.45.1",
+  "version": "0.46.0",
   "description": "XCPCIO Core",
   "author": "Dup4 <lyuzhi.pan@gmail.com>",
   "license": "MIT",
@@ -49,7 +49,7 @@
     "papaparse": "^5.4.1",
     "string-width": "^6.1.0",
     "xlsx-js-style": "^1.2.0",
-    "@xcpcio/types": "0.45.1"
+    "@xcpcio/types": "0.46.0"
   },
   "devDependencies": {
     "@babel/types": "^7.22.4",

package/src/contest.ts

@@ -10,6 +10,7 @@ import { type Awards, MedalType } from "./award";
 import { ContestOptions, createContestOptions } from "./contest-options";
 
 export class Contest {
+  id = "";
   name = "";
 
   startTime: dayjs.Dayjs;

package/src/index.ts

@@ -1,4 +1,5 @@
 export * from "./export";
+export * from "./rating";
 export * from "./utils";
 
 export * from "./award";

package/src/rank.ts

@@ -608,3 +608,5 @@ export class Rank {
     this.contest.setReplayTime(replayStartTimestamp);
   }
 }
+
+export type Ranks = Array<Rank>;

package/src/rating/index.ts

@@ -0,0 +1,4 @@
+export * from "./rating-calculator";
+export * from "./rating-history";
+export * from "./rating-user";
+export * from "./rating";

package/src/rating/rating-calculator.ts

@@ -0,0 +1,100 @@
+import type { RatingUsers } from "./rating-user";
+import { RatingUser } from "./rating-user";
+
+// https://www.wikiwand.com/en/Elo_rating_system
+export class RatingCalculator {
+  users: RatingUsers;
+
+  constructor() {
+    this.users = [];
+  }
+
+  calculate() {
+    this.calculateInternal();
+  }
+
+  private calcP(userA: RatingUser, userB: RatingUser) {
+    return 1.0 / (1.0 + 10 ** ((userB.oldRating - userA.oldRating) / 400.0));
+  }
+
+  private getExSeed(users: RatingUsers, rating: number, ownUser: RatingUser) {
+    const exUser = new RatingUser();
+    exUser.oldRating = rating;
+
+    let res = 0;
+
+    users.forEach((user) => {
+      if (user.id !== ownUser.id) {
+        res += this.calcP(user, exUser);
+      }
+    });
+
+    return res;
+  }
+
+  private calcRating(users: RatingUsers, rank: number, user: RatingUser) {
+    let left = 1;
+    let right = 8000;
+
+    while (right - left > 1) {
+      const mid = Math.floor((left + right) / 2);
+      if (this.getExSeed(users, mid, user) < rank) {
+        right = mid;
+      } else {
+        left = mid;
+      }
+    }
+
+    return left;
+  }
+
+  private calculateInternal() {
+    // Calculate seed
+    for (let i = 0; i < this.users.length; i++) {
+      const u = this.users[i];
+      u.seed = 1.0;
+      for (let j = 0; j < this.users.length; j++) {
+        if (i !== j) {
+          const otherUser = this.users[j];
+          u.seed += this.calcP(otherUser, u);
+        }
+      }
+    }
+
+    // Calculate initial delta and sumDelta
+    let sumDelta = 0;
+    for (let i = 0; i < this.users.length; i++) {
+      const u = this.users[i];
+      u.delta = Math.floor(
+        (this.calcRating(this.users, Math.sqrt(u.rank * u.seed), u)
+          - u.oldRating)
+          / 2,
+      );
+      sumDelta += u.delta;
+    }
+
+    // Calculate first inc
+    let inc = Math.floor(-sumDelta / this.users.length) - 1;
+    for (let i = 0; i < this.users.length; i++) {
+      const u = this.users[i];
+      u.delta += inc;
+    }
+
+    // Calculate second inc
+    this.users = this.users.sort((a, b) => b.oldRating - a.oldRating);
+    const s = Math.min(this.users.length, Math.floor(4 * Math.round(Math.sqrt(this.users.length))));
+    let sumS = 0;
+    for (let i = 0; i < s; i++) {
+      sumS += this.users[i].delta;
+    }
+    inc = Math.min(Math.max(Math.floor(-sumS / s), -10), 0);
+
+    // Calculate new rating
+    this.users.forEach((u) => {
+      u.delta += inc;
+      u.UpdateRating(u.oldRating + u.delta);
+    });
+
+    this.users = this.users.sort((a, b) => a.rank - b.rank);
+  }
+}

package/src/rating/rating-history.ts

@@ -0,0 +1,55 @@
+import type { IRatingHistory } from "@xcpcio/types";
+
+import type { dayjs } from "../utils";
+import { createDayJS } from "../utils";
+
+export class RatingHistory {
+  rank: number;
+  rating: number;
+
+  contestID: string;
+  contestName: string;
+  contestLink: string;
+  contestTime: dayjs.Dayjs;
+
+  constructor() {
+    this.rank = 0;
+    this.rating = 0;
+
+    this.contestID = "";
+    this.contestName = "";
+    this.contestLink = "";
+    this.contestTime = createDayJS();
+  }
+
+  toJSON(): IRatingHistory {
+    return {
+      rank: this.rank,
+      rating: this.rating,
+
+      contestID: this.contestID,
+      contestName: this.contestName,
+      contestLink: this.contestLink,
+      contestTime: this.contestTime.toDate(),
+    };
+  }
+
+  static fromJSON(iRatingHistory: IRatingHistory | string): RatingHistory {
+    if (typeof iRatingHistory === "string") {
+      iRatingHistory = JSON.parse(iRatingHistory) as IRatingHistory;
+    }
+
+    const ratingHistory = new RatingHistory();
+    ratingHistory.rank = iRatingHistory.rank;
+    ratingHistory.rating = iRatingHistory.rating;
+
+    ratingHistory.contestID = iRatingHistory.contestID;
+    ratingHistory.contestName = iRatingHistory.contestName;
+    ratingHistory.contestLink = iRatingHistory.contestLink;
+    ratingHistory.contestTime = createDayJS(iRatingHistory.contestTime);
+
+    return ratingHistory;
+  }
+}
+
+export type RatingHistories = Array<RatingHistory>;

package/src/rating/rating-user.ts

@@ -0,0 +1,79 @@
+import type { IRatingUser } from "@xcpcio/types/index";
+import { type RatingHistories, RatingHistory } from "./rating-history";
+
+export class RatingUser {
+  id: string;
+  name: string;
+
+  rating: number;
+  minRating: number;
+  maxRating: number;
+
+  rank: number;
+  oldRating: number;
+
+  seed: number;
+  delta: number;
+
+  ratingHistories: RatingHistories;
+
+  constructor() {
+    this.id = "";
+    this.name = "";
+
+    this.rating = 0;
+    this.minRating = 0x3F3F3F3F;
+    this.maxRating = -0x3F3F3F3F;
+
+    this.rank = 0;
+    this.oldRating = 0;
+
+    this.seed = 1.0;
+    this.delta = 0;
+
+    this.ratingHistories = [];
+  }
+
+  UpdateRating(rating: number) {
+    this.rating = rating;
+    this.minRating = Math.min(this.minRating, rating);
+    this.maxRating = Math.max(this.maxRating, rating);
+  }
+
+  toJSON(): IRatingUser {
+    return {
+      id: this.id,
+      name: this.name,
+
+      rating: this.rating,
+      minRating: this.minRating,
+      maxRating: this.maxRating,
+
+      ratingHistories: this.ratingHistories.map(ratingHistory => ratingHistory.toJSON()),
+    };
+  }
+
+  static fromJSON(iRatingUser: IRatingUser | string): RatingUser {
+    if (typeof iRatingUser === "string") {
+      iRatingUser = JSON.parse(iRatingUser) as IRatingUser;
+    }
+
+    const ratingUser = new RatingUser();
+
+    ratingUser.id = iRatingUser.id;
+    ratingUser.name = iRatingUser.name;
+
+    ratingUser.rating = iRatingUser.rating;
+    ratingUser.minRating = iRatingUser.minRating;
+    ratingUser.maxRating = iRatingUser.maxRating;
+
+    for (const iRatingHistory of iRatingUser.ratingHistories) {
+      ratingUser.ratingHistories.push(RatingHistory.fromJSON(iRatingHistory));
+    }
+
+    return ratingUser;
+  }
+}
+
+export type RatingUsers = Array<RatingUser>;
+export type RatingUserMap = Map<string, RatingUser>;

package/src/rating/rating.ts

@@ -0,0 +1,114 @@
+import type { IRating } from "@xcpcio/types/index";
+import type { Ranks } from "../rank";
+import type { Team } from "../team";
+
+import { RatingCalculator } from "./rating-calculator";
+import { RatingHistory } from "./rating-history";
+import type { RatingUserMap, RatingUsers } from "./rating-user";
+import { RatingUser } from "./rating-user";
+
+export class Rating {
+  id: string;
+  name: string;
+  baseRating: number;
+
+  contestIDs: string[];
+  users: RatingUsers;
+
+  ranks: Ranks;
+  userMap: RatingUserMap;
+
+  constructor() {
+    this.id = "";
+    this.name = "";
+    this.baseRating = 1500;
+
+    this.contestIDs = [];
+    this.users = [];
+
+    this.ranks = [];
+    this.userMap = new Map<string, RatingUser>();
+  }
+
+  buildRating() {
+    for (const rank of this.ranks) {
+      rank.buildRank();
+
+      for (const u of this.users) {
+        u.oldRating = u.rating;
+      }
+
+      for (const t of rank.teams) {
+        const id = this.generateTeamId(t);
+
+        if (!this.userMap.has(id)) {
+          const u = new RatingUser();
+          u.id = id;
+          u.name = t.name;
+          u.rank = t.rank;
+          u.oldRating = this.baseRating;
+          u.UpdateRating(this.baseRating);
+
+          this.userMap.set(id, u);
+          this.users.push(u);
+        }
+      }
+
+      const ratingCalculator = new RatingCalculator();
+      ratingCalculator.users = this.users;
+      ratingCalculator.calculate();
+
+      for (const u of this.users) {
+        const h = new RatingHistory();
+        h.rank = u.rank;
+        h.rating = u.rating;
+
+        h.contestID = rank.contest.id;
+        h.contestLink = h.contestID;
+        h.contestName = rank.contest.name;
+        h.contestTime = rank.contest.startTime;
+
+        u.ratingHistories.push(h);
+      }
+    }
+  }
+
+  generateTeamId(t: Team) {
+    if (Array.isArray(t.members) && t.members.length > 0) {
+      return t.members.join("|");
+    }
+
+    return `${t.organization}-${t.name}`;
+  }
+
+  toJSON(): IRating {
+    return {
+      id: this.id,
+      name: this.name,
+      baseRating: this.baseRating,
+
+      contestIDs: this.contestIDs,
+      users: this.users.map(ratingUser => ratingUser.toJSON()),
+    };
+  }
+
+  static fromJSON(iRating: IRating | string): Rating {
+    if (typeof iRating === "string") {
+      iRating = JSON.parse(iRating) as IRating;
+    }
+
+    const rating = new Rating();
+
+    rating.id = iRating.id;
+    rating.name = iRating.name;
+    rating.baseRating = iRating.baseRating;
+
+    rating.contestIDs = iRating.contestIDs;
+
+    for (const iUser of iRating.users) {
+      rating.users.push(RatingUser.fromJSON(iUser));
+    }
+
+    return rating;
+  }
+}