Regression test for bug 311414, by timeless

js/tests/ecma_3/RegExp/regress-311414.js

@@ -0,0 +1,83 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* ***** BEGIN LICENSE BLOCK *****
+ * Version: MPL 1.1/GPL 2.0/LGPL 2.1
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ * http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ *
+ * The Original Code is JavaScript Engine testing utilities.
+ *
+ * The Initial Developer of the Original Code is
+ * Mozilla Foundation.
+ * Portions created by the Initial Developer are Copyright (C) 2005
+ * the Initial Developer. All Rights Reserved.
+ *
+ * Contributor(s): timeless
+ *
+ * Alternatively, the contents of this file may be used under the terms of
+ * either the GNU General Public License Version 2 or later (the "GPL"), or
+ * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
+ * in which case the provisions of the GPL or the LGPL are applicable instead
+ * of those above. If you wish to allow use of your version of this file only
+ * under the terms of either the GPL or the LGPL, and not to allow others to
+ * use your version of this file under the terms of the MPL, indicate your
+ * decision by deleting the provisions above and replace them with the notice
+ * and other provisions required by the GPL or the LGPL. If you do not delete
+ * the provisions above, a recipient may use your version of this file under
+ * the terms of any one of the MPL, the GPL or the LGPL.
+ *
+ * ***** END LICENSE BLOCK ***** */
+//-----------------------------------------------------------------------------
+var bug = 311414;
+var summary = 'RegExp captured tail match should be O(N)';
+var actual = '';
+var expect = '';
+
+printBugNumber (bug);
+printStatus (summary);
+  
+function q1(n) {
+    var c = [];
+    c[Math.pow(10, n)] = 1;
+    c = c.join(" ");
+    var d = Date.now();
+    var e = c.match(/(.*)foo$/);
+    var f = Date.now();
+    return [f - d];
+}
+
+function q2(n) {
+    var c = [];
+    c[Math.pow(10, n)] = 1;
+    c = c.join(" ");
+    var d = Date.now();
+    var e = /foo$/.test(c) && c.match(/(.*)foo$/);
+    var f = Date.now();
+    return [f - d];
+}
+
+var data1 = {X:[], Y:[]};
+var data2 = {X:[], Y:[]};
+
+for (var x = 0; x < 5; x++)
+{
+  var y1 = q1(x);
+  var y2 = q2(x);
+  data1.X.push(x);
+  data1.Y.push(y1);
+  data2.X.push(x);
+  data2.Y.push(y2);
+}
+
+var order1 = BigO(data1);
+var order2 = BigO(data2);
+
+reportCompare(true, order1 < 2 , summary + ' BigO ' + order1 + ' < 2');
+reportCompare(true, order2 < 2 , summary + ' BigO ' + order2 + ' < 2');

js/tests/ecma_3/shell.js

@@ -199,6 +199,118 @@ function currentFunc()
     
 }
 
+
+/*
+  Calculate the "order" of a set of data points {X: [], Y: []}
+  by computing successive "derivatives" of the data until
+  the data is exhausted or the derivative is linear.
+*/
+function BigO(data)
+{
+  var order = 0;
+  var origLength = data.X.length;
+
+  while (data.X.length > 1)
+  {
+    var lr = new LinearRegression(data);
+    order++;
+    if (lr.SE < 0.01)
+    {
+      break;
+    }
+    data = dataDeriv(data);
+  }
+ 
+  if (order == origLength - 1)
+  {
+    order = Number.POSITIVE_INFINITY;
+  }
+  return order;
+
+  function LinearRegression(data)
+    {
+      // http://www.bearcave.com/misl/misl_tech/wavelets/stat/
+      /*
+        X0,X1...; Y0,Y1,...
+        b = sum( (Xi - Xavg)(Yi - Yavg) ) / sum ( (Xi - Xavg)*(Xi - Xavg) )
+        a = Yavg - b * Xavg
+        stddev*stddev = (sum( (Yi - Yavg) * (Yi - Yavg) ) - 
+        b * sum( (Xi - Xavg)*(Yi - Yavg) ) ) /
+        sum ( (Xi - Xavg) * (Xi - Xavg) )
+      */
+      var i;
+
+      if (data.X.length != data.Y.length)
+      {
+        throw 'LinearRegression: data point length mismatch';
+      }
+      if (data.X.length < 2)
+      {
+        throw 'LinearRegression: data point length < 2';
+      }
+      var length = data.X.length;
+      var X = data.X;
+      var Y = data.Y;
+
+      this.Xavg = 0;
+      this.Yavg = 0;
+
+      for (i = 0; i < length; i++)
+      {
+        this.Xavg += X[i];
+        this.Yavg += Y[i];
+      }
+
+      var sumXdiffYdiff = 0;
+      var sumXdiffsquared = 0;
+      var sumYdiffsquared = 0;
+
+      for (i = 0; i < length; i++)
+      {
+        var xDiff = (X[i] - this.Xavg);
+        var yDiff = (Y[i] - this.Yavg);
+
+        sumXdiffYdiff   += xDiff * yDiff;
+        sumXdiffsquared += xDiff * xDiff; 
+        sumYdiffsquared += yDiff * yDiff;
+      }
+
+      this.b = sumXdiffYdiff / sumXdiffsquared;
+      this.a = this.Yavg - this.b * this.Xavg;
+      // standard deviation of regression
+      this.sigma = Math.sqrt( (sumYdiffsquared - this.b * sumXdiffYdiff) / 
+                              (length - 2));
+      // standard error in b
+      this.SE = this.sigma / Math.sqrt(sumXdiffsquared);
+    }
+
+  function dataDeriv(data)
+    {
+      if (data.X.length != data.Y.length)
+      {
+        throw 'length mismatch';
+      }
+      var length = data.X.length;
+
+      if (length < 2)
+      {
+        throw 'length ' + length + ' must be >= 2';
+      }
+      var X = data.X;
+      var Y = data.Y;
+
+      var deriv = {X: [], Y: [] };
+
+      for (var i = 0; i < length - 1; i++)
+      {
+        deriv.X[i] = (X[i] + X[i+1])/2;
+        deriv.Y[i] = (Y[i+1] - Y[i])/(X[i+1] - X[i]);
+      }  
+      return deriv;
+    }
+
+}
+
 /* JavaScriptOptions
    encapsulate the logic for setting and retrieving the values
    of the javascript options.