Improve tests (#27)

- Cache real perfs for tests.
  Perf calculation code is pretty stable now so doesn't make a lot of sense to
  calculate the super slow real perfs in tests every time.
- Speed up convolution.
  Not noticeable in normal use, but speeds up tests a lot. Performance improved
  by about 130%.
- Fix Deno std version.

Author: meooow25

.github/workflows/deno.yml

@@ -1,4 +1,4 @@
-name: Deno CI
+name: Tests
 
 on:
   push:
@@ -9,13 +9,10 @@ on:
 jobs:
   test:
     runs-on: ubuntu-latest
-    strategy:
-      matrix:
-        filter: ['/^(?!perf)/', '/perf.*(1305|1326)/', '/perf.*(1342|1349)/', '/perf.*(1350|1352)/']
     steps:
     - uses: actions/checkout@v2
     - uses: denolib/setup-deno@master
       with:
         deno-version: v1.x
     - name: Run tests
-      run: deno test --allow-read --filter '${{ matrix.filter }}' carrot/tests/test-*.ts
+      run: deno test --allow-read carrot/tests/test-*.ts

carrot/src/background/predict.js

@@ -58,7 +58,7 @@ for (let i = -RATING_RANGE_LEN; i <= RATING_RANGE_LEN; i++) {
 
 const fftConv = new FFTConv(ELO_WIN_PROB.length + RATING_RANGE_LEN - 1);
 
-class RatingCalculator {
+export class RatingCalculator {
   constructor(contestants) {
     this.contestants = contestants;
     this.seed = null;

carrot/src/util/conv.js

@@ -1,19 +1,3 @@
-/**
- * Represents complex numbers.
- */
-class Complex {
-  constructor(re = 0, im = 0) {
-    this.re = re;
-    this.im = im;
-  }
-  conj() { return new Complex(this.re, -this.im); }
-  add(x) { return new Complex(this.re + x.re, this.im + x.im); }
-  sub(x) { return new Complex(this.re - x.re, this.im - x.im); }
-  mul(x) { return new Complex(this.re * x.re - this.im * x.im, this.re * x.im + this.im * x.re) }
-}
-
-Complex.I = new Complex(0, 1);
-
 /**
  * Performs convolution of real sequences using Cooley-Tukey FFT in O(n log n).
  *
@@ -30,40 +14,50 @@ export default class FFTConv {
       k++;
     }
     this.n = 1 << k;
-    this.w = new Array(this.n >> 1);
+    const n2 = this.n >> 1;
+    this.wr = [];
+    this.wi = [];
     const ang = 2 * Math.PI / this.n;
-    for (let i = 0; i < this.w.length; i++) {
-      this.w[i] = new Complex(Math.cos(i * ang), Math.sin(i * ang));
+    for (let i = 0; i < n2; i++) {
+      this.wr[i] = Math.cos(i * ang);
+      this.wi[i] = Math.sin(i * ang);
     }
-    this.rev = new Array(this.n);
+    this.rev = [];
     this.rev[0] = 0;
     for (let i = 1; i < this.n; i++) {
       this.rev[i] = (this.rev[i >> 1] >> 1) | ((i & 1) << (k - 1));
     }
   }
 
-  transform(a) {
-    if (a.length !== this.n) {
-      throw new Error(`a.length is ${a.length}, expected ${this.n}`);
-    }
-
+  reverse(a) {
     for (let i = 1; i < this.n; i++) {
       if (i < this.rev[i]) {
         const tmp = a[i];
         a[i] = a[this.rev[i]];
         a[this.rev[i]] = tmp;
       }
     }
+  }
+
+  transform(ar, ai) {
+    if (ar.length !== this.n) {
+      throw new Error(`a.length is ${ar.length}, expected ${this.n}`);
+    }
 
+    this.reverse(ar);
+    this.reverse(ai);
     for (let len = 2; len <= this.n; len <<= 1) {
       const half = len >> 1;
       const diff = this.n / len;
       for (let i = 0; i < this.n; i += len) {
         let pw = 0;
         for (let j = i; j < i + half; j++) {
-          const v = a[j + half].mul(this.w[pw]);
-          a[j + half] = a[j].sub(v);
-          a[j] = a[j].add(v);
+          const vr = ar[j + half] * this.wr[pw] - ai[j + half] * this.wi[pw];
+          const vi = ar[j + half] * this.wi[pw] + ai[j + half] * this.wr[pw];
+          ar[j + half] = ar[j] - vr;
+          ai[j + half] = ai[j] - vi;
+          ar[j] += vr;
+          ai[j] += vi;
           pw += diff;
         }
       }
@@ -81,32 +75,35 @@ export default class FFTConv {
         `a.length + b.length - 1 is ${a.length} + ${b.length} - 1 = ${resLen}, ` +
         `expected <= ${n}`);
     }
-    let c = new Array(n);
-    for (let i = 0; i < n; i++) {
-      c[i] = new Complex();
-    }
-    for (let i = 0; i < a.length; i++) {
-      c[i].re = a[i];
-    }
-    for (let i = 0; i < b.length; i++) {
-      c[i].im = b[i];
-    }
-    this.transform(c);
-    let res = new Array(n);
-    let tmpa = c[0].add(c[0].conj());
-    let tmpb = c[0].conj().sub(c[0]).mul(Complex.I);
-    res[0] = tmpa.mul(tmpb);
+    const cr = new Array(n).fill(0);
+    const ci = new Array(n).fill(0);
+    cr.splice(0, a.length, ...a);
+    ci.splice(0, b.length, ...b);
+    this.transform(cr, ci);
+
+    const dr = [];
+    const di = [];
+    let tar = 2 * cr[0];
+    let tai;
+    let tbr = 2 * ci[0];
+    let tbi;
+    dr[0] = tar * tbr;
+    di[0] = 0;
     for (let i = 1; i < n; i++) {
-      tmpa = c[i].add(c[n - i].conj());
-      tmpb = c[n - i].conj().sub(c[i]).mul(Complex.I);
-      res[i] = tmpa.mul(tmpb);
+      tar = cr[i] + cr[n - i];
+      tai = ci[i] - ci[n - i];
+      tbr = ci[n - i] + ci[i];
+      tbi = cr[n - i] - cr[i];
+      dr[i] = tar * tbr - tai * tbi;
+      di[i] = tar * tbi + tai * tbr;
     }
-    this.transform(res);
-    res[0] = res[0].re / (4 * n);
+
+    this.transform(dr, di);
+    const res = [];
+    res[0] = dr[0] / (4 * n);
     for (let i = 1, j = n - 1; i <= j; i++, j--) {
-      const tmp = res[i].re;
-      res[i] = res[j].re / (4 * n);
-      res[j] = tmp / (4 * n);
+      res[i] = dr[j] / (4 * n);
+      res[j] = dr[i] / (4 * n);
     }
     res.splice(resLen);
     return res;

carrot/tests/asserts.ts

@@ -1,7 +1,7 @@
 // Copyright 2018-2020 the Deno authors. All rights reserved. MIT license.
-import { AssertionError } from 'https://deno.land/std/testing/asserts.ts';
-import { red, green, white, gray, bold } from 'https://deno.land/std/fmt/colors.ts';
-import { diff, DiffType, DiffResult } from 'https://deno.land/std/testing/_diff.ts';
+import { AssertionError } from 'https://deno.land/std@0.76.0/testing/asserts.ts';
+import { red, green, white, gray, bold } from 'https://deno.land/std@0.76.0/fmt/colors.ts';
+import { diff, DiffType, DiffResult } from 'https://deno.land/std@0.76.0/testing/_diff.ts';
 
 // These are internal functions from https://deno.land/std/testing/asserts.ts.
 // We use these because we add a new assert function that allows an error margin
@@ -151,4 +151,4 @@ export function assertEqualsWithEps(
   throw new AssertionError(message);
 }
 
-export * from 'https://deno.land/std/testing/asserts.ts';
+export * from 'https://deno.land/std@0.76.0/testing/asserts.ts';

carrot/tests/compare.ts

@@ -1,4 +1,4 @@
-import * as colors from 'https://deno.land/std/fmt/colors.ts';
+import * as colors from 'https://deno.land/std@0.76.0/fmt/colors.ts';
 import * as api from '../src/background/cf-api.js';
 import predict, { Contestant } from '../src/background/predict.js';
 

carrot/tests/round-1305-ozon-2020-div1+2-data.json carrot/tests/data/round-1305-ozon-2020-div1+2-data.json

@@ -0,0 +1,30 @@
+import predict, { Contestant, PredictResult, MAX_RATING_LIMIT, MIN_RATING_LIMIT } from '../src/background/predict.js';
+import binarySearch from '../src/util/binsearch.js';
+
+/** Calculates the delta for a contestant with an assumed before-the-contest rating. */
+export function calcDelta(c: Contestant, contestants: Contestant[], assumedRating: number): number {
+  function replace(handle: string, assumedRating: number) {
+    return contestants.map(
+      (c) => c.handle === handle ? new Contestant(handle, c.points, c.penalty, assumedRating) : c);
+  }
+
+  const results: PredictResult[] = predict(replace(c.handle, assumedRating));
+  return results.filter((r) => r.handle === c.handle)[0].delta;
+}
+
+/** Calculates real performance values for the given handles. Very slow. */
+export function* calculateRealPerfs(contestants: Contestant[], handles: string[]): Generator<Contestant> {
+  const handlesSet = new Set(handles);
+  for (const c of contestants) {
+    if (!handlesSet.has(c.handle)) {
+      continue;
+    }
+    c.performance =
+        c.rank === 1 ?
+        Infinity :
+        binarySearch(
+            MIN_RATING_LIMIT, MAX_RATING_LIMIT,
+            (assumedRating: number) => calcDelta(c, contestants, assumedRating) <= 0);
+    yield c;
+  }
+}

carrot/tests/data/round-1305-ozon-2020-div1+2-perfs.json

@@ -1,39 +1,32 @@
-import predict, { Contestant, PredictResult, MAX_RATING_LIMIT, MIN_RATING_LIMIT } from '../src/background/predict.js';
-import binarySearch from '../src/util/binsearch.js'
+import { Contestant } from '../src/background/predict.js';
 
-// @ts-ignore: DedicatedWorkerGlobalScope
-self.onmessage = (e: MessageEvent): void => {
-  const contestants: Contestant[] = e.data.contestants;
-  const fastPerfs: Record<string, number | 'Infinity'> = e.data.fastPerfs;
+import { calcDelta, calculateRealPerfs } from './perf-util.ts';
 
-  function replace(handle: string, assumedRating: number) {
-    return contestants.map(
-      (c) => c.handle === handle ? new Contestant(handle, c.points, c.penalty, assumedRating) : c);
+// Local function to avoid net dependency
+function assert(value: boolean) {
+  if (!value) {
+    throw new Error('Assert failed');
   }
+}
 
-  function calcDelta(c: Contestant, assumedRating: number): number {
-    const results: PredictResult[] = predict(replace(c.handle, assumedRating));
-    return results.filter((r) => r.handle === c.handle)[0].delta;
-  }
+// @ts-ignore: DedicatedWorkerGlobalScope
+self.onmessage = (e: MessageEvent): void => {
+  const contestants: Contestant[] = e.data.contestants;
+  const handles: string[] = e.data.handles;
 
-  for (const c of contestants) {
-    const fastPerf = fastPerfs[c.handle];
-    if (fastPerfs[c.handle] === undefined) {
-      continue;
-    }
-    const result: Record<string, any> = {
-      fastPerf,
-      deltaAtFastPerf:
-          fastPerf === 'Infinity' ? c.rank === 1 ? 0 : '-Infinity' : calcDelta(c, fastPerf),
-      perf:
-          c.rank === 1 ?
-          'Infinity' :
-          binarySearch(
-              MIN_RATING_LIMIT, MAX_RATING_LIMIT,
-              (assumedRating: number) => calcDelta(c, assumedRating) <= 0),
+  for (const c of calculateRealPerfs(contestants, handles)) {
+    const result = {
+      handle: c.handle,
+      perf: c.performance === Infinity ? 'Infinity': c.performance,
     };
-    result.deltaAtPerf = c.rank === 1 ? 0 : calcDelta(c, result.perf),
-
+    let deltaAtPerf;
+    if (c.rank === 1) {
+      assert(c.performance === Infinity);
+      deltaAtPerf = 0;
+    } else {
+      deltaAtPerf = calcDelta(c, contestants, c.performance);
+    }
+    assert(deltaAtPerf === 0);
     // @ts-ignore: DedicatedWorkerGlobalScope
     self.postMessage(result);
   }