PerformanceTests/Animometer/resources/extensions.js

   1 Utilities =
   2 {
   3     _parse: function(str, sep)
   4     {
   5         var output = {};
   6         str.split(sep).forEach(function(part) {
   7             var item = part.split("=");
   8             var value = decodeURIComponent(item[1]);
   9             if (value[0] == "'" )
  10                 output[item[0]] = value.substr(1, value.length - 2);
  11             else
  12                 output[item[0]] = value;
  13           });
  14         return output;
  15     },
  16
  17     parseParameters: function()
  18     {
  19         return this._parse(window.location.search.substr(1), "&");
  20     },
  21
  22     parseArguments: function(str)
  23     {
  24         return this._parse(str, " ");
  25     },
  26
  27     extendObject: function(obj1, obj2)
  28     {
  29         for (var attrname in obj2)
  30             obj1[attrname] = obj2[attrname];
  31         return obj1;
  32     },
  33
  34     copyObject: function(obj)
  35     {
  36         return this.extendObject({}, obj);
  37     },
  38
  39     mergeObjects: function(obj1, obj2)
  40     {
  41         return this.extendObject(this.copyObject(obj1), obj2);
  42     },
  43
  44     createClass: function(classConstructor, classMethods)
  45     {
  46         classConstructor.prototype = classMethods;
  47         return classConstructor;
  48     },
  49
  50     createSubclass: function(superclass, classConstructor, classMethods)
  51     {
  52         classConstructor.prototype = Object.create(superclass.prototype);
  53         classConstructor.prototype.constructor = classConstructor;
  54         if (classMethods)
  55             Utilities.extendObject(classConstructor.prototype, classMethods);
  56         return classConstructor;
  57     },
  58
  59     createElement: function(name, attrs, parentElement)
  60     {
  61         var element = document.createElement(name);
  62
  63         for (var key in attrs)
  64             element.setAttribute(key, attrs[key]);
  65
  66         parentElement.appendChild(element);
  67         return element;
  68     },
  69
  70     createSVGElement: function(name, attrs, xlinkAttrs, parentElement)
  71     {
  72         const svgNamespace = "http://www.w3.org/2000/svg";
  73         const xlinkNamespace = "http://www.w3.org/1999/xlink";
  74
  75         var element = document.createElementNS(svgNamespace, name);
  76
  77         for (var key in attrs)
  78             element.setAttribute(key, attrs[key]);
  79
  80         for (var key in xlinkAttrs)
  81             element.setAttributeNS(xlinkNamespace, key, xlinkAttrs[key]);
  82
  83         parentElement.appendChild(element);
  84         return element;
  85     },
  86
  87     browserPrefix: function()
  88     {
  89         // Get the HTML element's CSSStyleDeclaration
  90         var styles = window.getComputedStyle(document.documentElement, '');
  91
  92         // Convert the styles list to an array
  93         var stylesArray = Array.prototype.slice.call(styles);
  94
  95         // Concatenate all the styles in one big string
  96         var stylesString = stylesArray.join('');
  97
  98         // Search the styles string for a known prefix type, settle on Opera if none is found.
  99         var prefixes = stylesString.match(/-(moz|webkit|ms)-/) || (styles.OLink === '' && ['', 'o']);
 100
 101         // prefixes has two elements; e.g. for webkit it has ['-webkit-', 'webkit'];
 102         var prefix = prefixes[1];
 103
 104         // Have 'O' before 'Moz' in the string so it is matched first.
 105         var dom = ('WebKit|O|Moz|MS').match(new RegExp(prefix, 'i'))[0];
 106
 107         // Return all the required prefixes.
 108         return {
 109             dom: dom,
 110             lowercase: prefix,
 111             css: '-' + prefix + '-',
 112             js: prefix[0].toUpperCase() + prefix.substr(1)
 113         };
 114     },
 115
 116     setElementPrefixedProperty: function(element, property, value)
 117     {
 118         element.style[property] = element.style[this.browserPrefix().js + property[0].toUpperCase() + property.substr(1)] = value;
 119     },
 120
 121     progressValue: function(value, min, max)
 122     {
 123         return (value - min) / (max - min);
 124     },
 125
 126     lerp: function(value, min, max)
 127     {
 128         return min + (max - min) * value;
 129     }
 130 };
 131
 132 Array.prototype.swap = function(i, j)
 133 {
 134     var t = this[i];
 135     this[i] = this[j];
 136     this[j] = t;
 137     return this;
 138 }
 139
 140 if (!Array.prototype.fill) {
 141     Array.prototype.fill = function(value) {
 142         if (this == null)
 143             throw new TypeError('Array.prototype.fill called on null or undefined');
 144
 145         var object = Object(this);
 146         var len = parseInt(object.length, 10);
 147         var start = arguments[1];
 148         var relativeStart = parseInt(start, 10) || 0;
 149         var k = relativeStart < 0 ? Math.max(len + relativeStart, 0) : Math.min(relativeStart, len);
 150         var end = arguments[2];
 151         var relativeEnd = end === undefined ? len : (parseInt(end) || 0) ;
 152         var final = relativeEnd < 0 ? Math.max(len + relativeEnd, 0) : Math.min(relativeEnd, len);
 153
 154         for (; k < final; k++)
 155             object[k] = value;
 156
 157         return object;
 158     };
 159 }
 160
 161 if (!Array.prototype.find) {
 162     Array.prototype.find = function(predicate) {
 163         if (this == null)
 164             throw new TypeError('Array.prototype.find called on null or undefined');
 165         if (typeof predicate !== 'function')
 166             throw new TypeError('predicate must be a function');
 167
 168         var list = Object(this);
 169         var length = list.length >>> 0;
 170         var thisArg = arguments[1];
 171         var value;
 172
 173         for (var i = 0; i < length; i++) {
 174             value = list[i];
 175             if (predicate.call(thisArg, value, i, list))
 176                 return value;
 177         }
 178         return undefined;
 179     };
 180 }
 181
 182 Array.prototype.shuffle = function()
 183 {
 184     for (var index = this.length - 1; index >= 0; --index) {
 185         var randomIndex = Math.floor(Math.random() * (index + 1));
 186         this.swap(index, randomIndex);
 187     }
 188     return this;
 189 }
 190
 191 Point = Utilities.createClass(
 192     function(x, y)
 193     {
 194         this.x = x;
 195         this.y = y;
 196     }, {
 197
 198     // Used when the point object is used as a size object.
 199     get width()
 200     {
 201         return this.x;
 202     },
 203
 204     // Used when the point object is used as a size object.
 205     get height()
 206     {
 207         return this.y;
 208     },
 209
 210     // Used when the point object is used as a size object.
 211     get center()
 212     {
 213         return new Point(this.x / 2, this.y / 2);
 214     },
 215
 216     str: function()
 217     {
 218         return "x = " + this.x + ", y = " + this.y;
 219     },
 220
 221     add: function(other)
 222     {
 223         if(isNaN(other.x))
 224             return new Point(this.x + other, this.y + other);
 225         return new Point(this.x + other.x, this.y + other.y);
 226     },
 227
 228     subtract: function(other)
 229     {
 230         if(isNaN(other.x))
 231             return new Point(this.x - other, this.y - other);
 232         return new Point(this.x - other.x, this.y - other.y);
 233     },
 234
 235     multiply: function(other)
 236     {
 237         if(isNaN(other.x))
 238             return new Point(this.x * other, this.y * other);
 239         return new Point(this.x * other.x, this.y * other.y);
 240     },
 241
 242     move: function(angle, velocity, timeDelta)
 243     {
 244         return this.add(Point.pointOnCircle(angle, velocity * (timeDelta / 1000)));
 245     },
 246
 247     length: function() {
 248         return Math.sqrt( this.x * this.x + this.y * this.y );
 249     },
 250
 251     normalize: function() {
 252         var l = Math.sqrt( this.x * this.x + this.y * this.y );
 253         this.x /= l;
 254         this.y /= l;
 255         return this;
 256     }
 257 });
 258
 259 Utilities.extendObject(Point, {
 260     zero: function()
 261     {
 262         return new Point(0, 0);
 263     },
 264
 265     pointOnCircle: function(angle, radius)
 266     {
 267         return new Point(radius * Math.cos(angle), radius * Math.sin(angle));
 268     },
 269
 270     pointOnEllipse: function(angle, radiuses)
 271     {
 272         return new Point(radiuses.x * Math.cos(angle), radiuses.y * Math.sin(angle));
 273     },
 274
 275     elementClientSize: function(element)
 276     {
 277         var rect = element.getBoundingClientRect();
 278         return new Point(rect.width, rect.height);
 279     }
 280 });
 281
 282 Insets = Utilities.createClass(
 283     function(top, right, bottom, left)
 284     {
 285         this.top = top;
 286         this.right = right;
 287         this.bottom = bottom;
 288         this.left = left;
 289     }, {
 290
 291     get width()
 292     {
 293         return this.left + this.right;
 294     },
 295
 296     get height()
 297     {
 298         return this.top + this.bottom;
 299     },
 300
 301     get size()
 302     {
 303         return new Point(this.width, this.height);
 304     }
 305 });
 306
 307 Insets.elementPadding = function(element)
 308 {
 309     var styles = window.getComputedStyle(element);
 310     return new Insets(
 311         parseFloat(styles.paddingTop),
 312         parseFloat(styles.paddingRight),
 313         parseFloat(styles.paddingBottom),
 314         parseFloat(styles.paddingTop));
 315 }
 316
 317 SimplePromise = Utilities.createClass(
 318     function()
 319     {
 320         this._chainedPromise = null;
 321         this._callback = null;
 322     }, {
 323
 324     then: function (callback)
 325     {
 326         if (this._callback)
 327             throw "SimplePromise doesn't support multiple calls to then";
 328
 329         this._callback = callback;
 330         this._chainedPromise = new SimplePromise;
 331
 332         if (this._resolved)
 333             this.resolve(this._resolvedValue);
 334
 335         return this._chainedPromise;
 336     },
 337
 338     resolve: function (value)
 339     {
 340         if (!this._callback) {
 341             this._resolved = true;
 342             this._resolvedValue = value;
 343             return;
 344         }
 345
 346         var result = this._callback(value);
 347         if (result instanceof SimplePromise) {
 348             var chainedPromise = this._chainedPromise;
 349             result.then(function (result) { chainedPromise.resolve(result); });
 350         } else
 351             this._chainedPromise.resolve(result);
 352     }
 353 });
 354
 355 Statistics =
 356 {
 357     sampleMean: function(numberOfSamples, sum)
 358     {
 359         if (numberOfSamples < 1)
 360             return 0;
 361         return sum / numberOfSamples;
 362     },
 363
 364     // With sum and sum of squares, we can compute the sample standard deviation in O(1).
 365     // See https://rniwa.com/2012-11-10/sample-standard-deviation-in-terms-of-sum-and-square-sum-of-samples/
 366     unbiasedSampleStandardDeviation: function(numberOfSamples, sum, squareSum)
 367     {
 368         if (numberOfSamples < 2)
 369             return 0;
 370         return Math.sqrt((squareSum - sum * sum / numberOfSamples) / (numberOfSamples - 1));
 371     },
 372
 373     geometricMean: function(values)
 374     {
 375         if (!values.length)
 376             return 0;
 377         var roots = values.map(function(value) { return  Math.pow(value, 1 / values.length); })
 378         return roots.reduce(function(a, b) { return a * b; });
 379     }
 380 };