Source: eval/result/AverageGenMatchResult.js

  1. /**
  2.  * The average of many gen match results.
  3.  *
  4.  * @see {GenMatchTestResult}
  5.  */
  6. export class AverageGenMatchResult {
  7.   /**
  8.    * The matching algorithm that produced the match results.
  9.    * @type {String}
  10.    * @const
  11.    */
  12.   algorithm;
  13.   /**
  14.    * The name of the match test case configuration that was run multiple times.
  15.    * @type {String}
  16.    * @const
  17.    */
  18.   caseName;
  19.   /**
  20.    * The time (in ms) it took to produced the result. Null indicates failure.
  21.    * @type {?Number}
  22.    * @const
  23.    */
  24.   avgRuntime;
  25.   /**
  26.    * The avgCommonality between the expected and actual matching as a comparison
  27.    * value.
  28.    * @type {Number}
  29.    * @const
  30.    */
  31.   avgCommonality;
  32.   /**
  33.    * The number of mismatched leaves.
  34.    * @type {Number}
  35.    * @const
  36.    */
  37.   avgMismatchedLeaves;
  38.   /**
  39.    * The number of mismatched inner nodes.
  40.    * @type {Number}
  41.    * @const
  42.    */
  43.   avgMismatchedInners;
  44.   /**
  45.    * The number of leaves that are matched in the expected, but not the actual,
  46.    * matching.
  47.    * @type {Number}
  48.    * @const
  49.    */
  50.   avgUnmatchedLeaves;
  51.   /**
  52.    * The number of inner nodes that are matched in the expected, but not the
  53.    * actual, matching.
  54.    * @type {Number}
  55.    * @const
  56.    */
  57.   avgUnmatchedInners;
  59.   /**
  60.    * Construct a new GenMatchTestResult instance.
  61.    * @param {String} caseName The name of the corresponding diff test case.
  62.    * @param {String} algorithm The name of the algorithm that produced the
  63.    *     matching.
  64.    * @param {Number} avgRuntime The average time (in ms) it took to produced
  65.    *     the
  66.    *     result. Null indicates failure.
  67.    * @param {Number} avgCommonality The average avgCommonality between the
  68.    *     expected and actual matching as a comparison value.
  69.    * @param {Number} avgMismatchedLeaves The average number of mismatched
  70.    *     leaves.
  71.    * @param {Number} avgMismatchedInners The average number of mismatched inner
  72.    *     nodes.
  73.    * @param {Number} avgUnmatchedLeaves The average number of leaves that are
  74.    *     matched in the expected, but not the actual, matching.
  75.    * @param {Number} avgUnmatchedInners The average number of inner nodes that
  76.    *     are matched in the expected, but not the actual, matching.
  77.    */
  78.   constructor(
  79.       caseName,
  80.       algorithm,
  81.       avgRuntime,
  82.       avgCommonality,
  83.       avgMismatchedLeaves,
  84.       avgMismatchedInners,
  85.       avgUnmatchedLeaves,
  86.       avgUnmatchedInners,
  87.   ) {
  88.     this.caseName = caseName;
  89.     this.algorithm = algorithm;
  90.     this.avgRuntime = avgRuntime;
  91.     this.avgMismatchedInners = avgMismatchedInners;
  92.     this.avgMismatchedLeaves = avgMismatchedLeaves;
  93.     this.avgCommonality = avgCommonality;
  94.     this.avgUnmatchedLeaves = avgUnmatchedLeaves;
  95.     this.avgUnmatchedInners = avgUnmatchedInners;
  96.   }
  98.   /**
  99.    * @return {Array<String>} The header row for a list of average gen match test
  100.    *     results to use in tables.
  101.    */
  102.   static header() {
  103.     return [
  104.       'Algorithm',
  105.       'Avg Runtime',
  106.       'Avg Commonality',
  107.       'Avg Mismatched Leaves',
  108.       'Avg Mismatched Inners',
  109.       'Avg Unmatched Leaves',
  110.       'Avg Unmatched Inners',
  111.     ];
  112.   }
  114.   /**
  115.    * Construct an AverageGenMatchResult instance from a list of gen match test
  116.    * results pertaining to the same test case configuration. Results that
  117.    * indicate a timeout or runtime error are ignored during the metric
  118.    * calculation.
  119.    * @param {Array<GenMatchTestResult>} genMatchResults The list of gen match
  120.    *     test results.
  121.    * @return {?AverageGenMatchResult} Derived metrics for the results. Null if
  122.    *     no valid results were found.
  123.    */
  124.   static of(genMatchResults) {
  125.     // Only consider test case executions that didnt result in an error or
  126.     // timeout
  127.     genMatchResults = genMatchResults.filter((r) => r.isOk());
  128.     if (genMatchResults.length === 0) {
  129.       // Cannot produce averages
  130.       return null;
  131.     }
  132.     const caseName = genMatchResults[0].caseName;
  133.     const algorithm = genMatchResults[0].algorithm;
  135.     const avg = (arr) => arr.reduce((a, b) => a + b, 0) / arr.length;
  137.     return new AverageGenMatchResult(
  138.         caseName,
  139.         algorithm,
  140.         avg(genMatchResults.map((result) => result.runtime)),
  141.         avg(genMatchResults.map((result) => result.commonality)),
  142.         avg(genMatchResults.map((result) => result.mismatchedLeaves)),
  143.         avg(genMatchResults.map((result) => result.mismatchedInners)),
  144.         avg(genMatchResults.map((result) => result.unmatchedLeaves)),
  145.         avg(genMatchResults.map((result) => result.unmatchedInners)),
  146.     );
  147.   }
  149.   /**
  150.    * @return {Array<String>} The row of values of this result for use in tables.
  151.    */
  152.   values() {
  153.     // A non-OK verdict indicates failure, fill the  array with it
  154.     return [
  155.       this.algorithm,
  156.       this.avgRuntime,
  157.       this.avgCommonality,
  158.       this.avgMismatchedLeaves,
  159.       this.avgUnmatchedInners,
  160.       this.avgUnmatchedLeaves,
  161.       this.avgUnmatchedInners,
  162.     ];
  163.   }
  164. }