closure 1.1.692

data/closure-library/closure/goog/math/math.js

@@ -0,0 +1,355 @@
+// Copyright 2006 The Closure Library Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (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.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS-IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+/**
+ * @fileoverview Additional mathematical functions.
+ */
+
+goog.provide('goog.math');
+
+goog.require('goog.array');
+
+
+/**
+ * Returns a random integer greater than or equal to 0 and less than {@code a}.
+ * @param {number} a  The upper bound for the random integer (exclusive).
+ * @return {number} A random integer N such that 0 <= N < a.
+ */
+goog.math.randomInt = function(a) {
+  return Math.floor(Math.random() * a);
+};
+
+
+/**
+ * Returns a random number greater than or equal to {@code a} and less than
+ * {@code b}.
+ * @param {number} a  The lower bound for the random number (inclusive).
+ * @param {number} b  The upper bound for the random number (exclusive).
+ * @return {number} A random number N such that a <= N < b.
+ */
+goog.math.uniformRandom = function(a, b) {
+  return a + Math.random() * (b - a);
+};
+
+
+/**
+ * Takes a number and clamps it to within the provided bounds.
+ * @param {number} value The input number.
+ * @param {number} min The minimum value to return.
+ * @param {number} max The maximum value to return.
+ * @return {number} The input number if it is within bounds, or the nearest
+ *     number within the bounds.
+ */
+goog.math.clamp = function(value, min, max) {
+  return Math.min(Math.max(value, min), max);
+};
+
+
+/**
+ * The % operator in JavaScript returns the remainder of a / b, but differs from
+ * some other languages in that the result will have the same sign as the
+ * dividend. For example, -1 % 8 == -1, whereas in some other languages
+ * (such as Python) the result would be 7. This function emulates the more
+ * correct modulo behavior, which is useful for certain applications such as
+ * calculating an offset index in a circular list.
+ *
+ * @param {number} a The dividend.
+ * @param {number} b The divisor.
+ * @return {number} a % b where the result is between 0 and b (either 0 <= x < b
+ *     or b < x <= 0, depending on the sign of b).
+ */
+goog.math.modulo = function(a, b) {
+  var r = a % b;
+  // If r and b differ in sign, add b to wrap the result to the correct sign.
+  return (r * b < 0) ? r + b : r;
+};
+
+
+/**
+ * Performs linear interpolation between values a and b. Returns the value
+ * between a and b proportional to x (when x is between 0 and 1. When x is
+ * outside this range, the return value is a linear extrapolation).
+ * @param {number} a A number.
+ * @param {number} b A number.
+ * @param {number} x The proportion between a and b.
+ * @return {number} The interpolated value between a and b.
+ */
+goog.math.lerp = function(a, b, x) {
+  return a + x * (b - a);
+};
+
+
+/**
+ * Tests whether the two values are equal to each other, within a certain
+ * tolerance to adjust for floating pount errors.
+ * @param {number} a A number.
+ * @param {number} b A number.
+ * @param {number=} opt_tolerance Optional tolerance range. Defaults
+ *     to 0.000001. If specified, should be greater than 0.
+ * @return {boolean} Whether {@code a} and {@code b} are nearly equal.
+ */
+goog.math.nearlyEquals = function(a, b, opt_tolerance) {
+  return Math.abs(a - b) <= (opt_tolerance || 0.000001);
+};
+
+
+/**
+ * Standardizes an angle to be in range [0-360). Negative angles become
+ * positive, and values greater than 360 are returned modulo 360.
+ * @param {number} angle Angle in degrees.
+ * @return {number} Standardized angle.
+ */
+goog.math.standardAngle = function(angle) {
+  return goog.math.modulo(angle, 360);
+};
+
+
+/**
+ * Converts degrees to radians.
+ * @param {number} angleDegrees Angle in degrees.
+ * @return {number} Angle in radians.
+ */
+goog.math.toRadians = function(angleDegrees) {
+  return angleDegrees * Math.PI / 180;
+};
+
+
+/**
+ * Converts radians to degrees.
+ * @param {number} angleRadians Angle in radians.
+ * @return {number} Angle in degrees.
+ */
+goog.math.toDegrees = function(angleRadians) {
+  return angleRadians * 180 / Math.PI;
+};
+
+
+/**
+ * For a given angle and radius, finds the X portion of the offset.
+ * @param {number} degrees Angle in degrees (zero points in +X direction).
+ * @param {number} radius Radius.
+ * @return {number} The x-distance for the angle and radius.
+ */
+goog.math.angleDx = function(degrees, radius) {
+  return radius * Math.cos(goog.math.toRadians(degrees));
+};
+
+
+/**
+ * For a given angle and radius, finds the Y portion of the offset.
+ * @param {number} degrees Angle in degrees (zero points in +X direction).
+ * @param {number} radius Radius.
+ * @return {number} The y-distance for the angle and radius.
+ */
+goog.math.angleDy = function(degrees, radius) {
+  return radius * Math.sin(goog.math.toRadians(degrees));
+};
+
+
+/**
+ * Computes the angle between two points (x1,y1) and (x2,y2).
+ * Angle zero points in the +X direction, 90 degrees points in the +Y
+ * direction (down) and from there we grow clockwise towards 360 degrees.
+ * @param {number} x1 x of first point.
+ * @param {number} y1 y of first point.
+ * @param {number} x2 x of second point.
+ * @param {number} y2 y of second point.
+ * @return {number} Standardized angle in degrees of the vector from
+ *     x1,y1 to x2,y2.
+ */
+goog.math.angle = function(x1, y1, x2, y2) {
+  return goog.math.standardAngle(goog.math.toDegrees(Math.atan2(y2 - y1,
+                                                                x2 - x1)));
+};
+
+
+/**
+ * Computes the difference between startAngle and endAngle (angles in degrees).
+ * @param {number} startAngle  Start angle in degrees.
+ * @param {number} endAngle  End angle in degrees.
+ * @return {number} The number of degrees that when added to
+ *     startAngle will result in endAngle. Positive numbers mean that the
+ *     direction is clockwise. Negative numbers indicate a counter-clockwise
+ *     direction.
+ *     The shortest route (clockwise vs counter-clockwise) between the angles
+ *     is used.
+ *     When the difference is 180 degrees, the function returns 180 (not -180)
+ *     angleDifference(30, 40) is 10, and angleDifference(40, 30) is -10.
+ *     angleDifference(350, 10) is 20, and angleDifference(10, 350) is -20.
+ */
+goog.math.angleDifference = function(startAngle, endAngle) {
+  var d = goog.math.standardAngle(endAngle) -
+          goog.math.standardAngle(startAngle);
+  if (d > 180) {
+    d = d - 360;
+  } else if (d <= -180) {
+    d = 360 + d;
+  }
+  return d;
+};
+
+
+/**
+ * Returns the sign of a number as per the "sign" or "signum" function.
+ * @param {number} x The number to take the sign of.
+ * @return {number} -1 when negative, 1 when positive, 0 when 0.
+ */
+goog.math.sign = function(x) {
+  return x == 0 ? 0 : (x < 0 ? -1 : 1);
+};
+
+
+/**
+ * JavaScript implementation of Longest Common Subsequence problem.
+ * http://en.wikipedia.org/wiki/Longest_common_subsequence
+ *
+ * Returns the longest possible array that is subarray of both of given arrays.
+ *
+ * @param {Array.<Object>} array1 First array of objects.
+ * @param {Array.<Object>} array2 Second array of objects.
+ * @param {Function=} opt_compareFn Function that acts as a custom comparator
+ *     for the array ojects. Function should return true if objects are equal,
+ *     otherwise false.
+ * @param {Function=} opt_collectorFn Function used to decide what to return
+ *     as a result subsequence. It accepts 2 arguments: index of common element
+ *     in the first array and index in the second. The default function returns
+ *     element from the first array.
+ * @return {Array.<Object>} A list of objects that are common to both arrays
+ *     such that there is no common subsequence with size greater than the
+ *     length of the list.
+ */
+goog.math.longestCommonSubsequence = function(
+    array1, array2, opt_compareFn, opt_collectorFn) {
+
+  var compare = opt_compareFn || function(a, b) {
+    return a == b;
+  };
+
+  var collect = opt_collectorFn || function(i1, i2) {
+    return array1[i1];
+  };
+
+  var length1 = array1.length;
+  var length2 = array2.length;
+
+  var arr = [];
+  for (var i = 0; i < length1 + 1; i++) {
+    arr[i] = [];
+    arr[i][0] = 0;
+  }
+
+  for (var j = 0; j < length2 + 1; j++) {
+    arr[0][j] = 0;
+  }
+
+  for (i = 1; i <= length1; i++) {
+    for (j = 1; j <= length1; j++) {
+      if (compare(array1[i - 1], array2[j - 1])) {
+        arr[i][j] = arr[i - 1][j - 1] + 1;
+      } else {
+        arr[i][j] = Math.max(arr[i - 1][j], arr[i][j - 1]);
+      }
+    }
+  }
+
+  // Backtracking
+  var result = [];
+  var i = length1, j = length2;
+  while (i > 0 && j > 0) {
+    if (compare(array1[i - 1], array2[j - 1])) {
+      result.unshift(collect(i - 1, j - 1));
+      i--;
+      j--;
+    } else {
+      if (arr[i - 1][j] > arr[i][j - 1]) {
+        i--;
+      } else {
+        j--;
+      }
+    }
+  }
+
+  return result;
+};
+
+
+/**
+ * Returns the sum of the arguments.
+ * @param {...number} var_args Numbers to add.
+ * @return {number} The sum of the arguments (0 if no arguments were provided,
+ *     {@code NaN} if any of the arguments is not a valid number).
+ */
+goog.math.sum = function(var_args) {
+  return /** @type {number} */ (goog.array.reduce(arguments,
+      function(sum, value) {
+        return sum + value;
+      }, 0));
+};
+
+
+/**
+ * Returns the arithmetic mean of the arguments.
+ * @param {...number} var_args Numbers to average.
+ * @return {number} The average of the arguments ({@code NaN} if no arguments
+ *     were provided or any of the arguments is not a valid number).
+ */
+goog.math.average = function(var_args) {
+  return goog.math.sum.apply(null, arguments) / arguments.length;
+};
+
+
+/**
+ * Returns the sample standard deviation of the arguments.  For a definition of
+ * sample standard deviation, see e.g.
+ * http://en.wikipedia.org/wiki/Standard_deviation
+ * @param {...number} var_args Number samples to analyze.
+ * @return {number} The sample standard deviation of the arguments (0 if fewer
+ *     than two samples were provided, or {@code NaN} if any of the samples is
+ *     not a valid number).
+ */
+goog.math.standardDeviation = function(var_args) {
+  var sampleSize = arguments.length;
+  if (sampleSize < 2) {
+    return 0;
+  }
+
+  var mean = goog.math.average.apply(null, arguments);
+  var variance = goog.math.sum.apply(null, goog.array.map(arguments,
+      function(val) {
+        return Math.pow(val - mean, 2);
+      })) / (sampleSize - 1);
+
+  return Math.sqrt(variance);
+};
+
+
+/**
+ * Returns whether the supplied number represents an integer, i.e. that is has
+ * no fractional component.  No range-checking is performed on the number.
+ * @param {number} num The number to test.
+ * @return {boolean} Whether {@code num} is an integer.
+ */
+goog.math.isInt = function(num) {
+  return isFinite(num) && num % 1 == 0;
+};
+
+
+/**
+ * Returns whether the supplied number is finite and not NaN.
+ * @param {number} num The number to test.
+ * @return {boolean} Whether {@code num} is a finite number.
+ */
+goog.math.isFiniteNumber = function(num) {
+  return isFinite(num) && !isNaN(num);
+};

data/closure-library/closure/goog/math/math_test.html

@@ -0,0 +1,254 @@
+<!DOCTYPE html>
+<html>
+<!--
+Copyright 2006 The Closure Library Authors. All Rights Reserved.
+
+Use of this source code is governed by the Apache License, Version 2.0.
+See the COPYING file for details.
+-->
+<head>
+<meta http-equiv="X-UA-Compatible" content="IE=edge">
+  <title>Closure Unit Tests - goog.math</title>
+  <script src="../base.js"></script>
+  <script>
+    goog.require('goog.math');
+    goog.require('goog.testing.jsunit');
+  </script>
+</head>
+<body>
+  <script>
+    function testRandomInt() {
+      assertEquals(0, goog.math.randomInt(0));
+      assertEquals(0, goog.math.randomInt(1));
+
+      var r = goog.math.randomInt(3);
+      assertTrue(0 <= r && r < 3);
+    }
+
+    function testUniformRandom() {
+      assertEquals(5.2, goog.math.uniformRandom(5.2, 5.2));
+      assertEquals(-6, goog.math.uniformRandom(-6, -6));
+
+      var r = goog.math.uniformRandom(-0.5, 0.5);
+      assertTrue(-0.5 <= r && r < 0.5);
+    }
+
+    function testClamp() {
+      assertEquals(3, goog.math.clamp(3, -5, 5));
+      assertEquals(5, goog.math.clamp(5, -5, 5));
+      assertEquals(-5, goog.math.clamp(-5, -5, 5));
+
+      assertEquals(-5, goog.math.clamp(-22, -5, 5));
+      assertEquals(5, goog.math.clamp(6, -5, 5));
+    }
+
+    function testModulo() {
+      assertEquals(0, goog.math.modulo(256, 8));
+
+      assertEquals(7, goog.math.modulo(7, 8));
+      assertEquals(7, goog.math.modulo(23, 8));
+      assertEquals(7, goog.math.modulo(-1, 8));
+
+      assertEquals(-4, goog.math.modulo(1, -5));
+      assertEquals(-4, goog.math.modulo(6, -5));
+      assertEquals(-4, goog.math.modulo(-4, -5));
+    }
+
+    function testLerp() {
+      assertEquals(0, goog.math.lerp(0, 0, 0));
+      assertEquals(3, goog.math.lerp(0, 6, 0.5));
+      assertEquals(3, goog.math.lerp(-1, 1, 2));
+    }
+
+    function testNearlyEquals() {
+      assertTrue('Numbers inside default tolerance should be equal',
+                 goog.math.nearlyEquals(0.000001, 0.000001001));
+      assertFalse('Numbers outside default tolerance should be unequal',
+                  goog.math.nearlyEquals(0.000001, 0.000003));
+      assertTrue('Numbers inside custom tolerance should be equal',
+                 goog.math.nearlyEquals(0.001, 0.002, 0.1));
+      assertFalse('Numbers outside custom tolerance should be unequal',
+                  goog.math.nearlyEquals(0.001, -0.1, 0.1));
+      assertTrue('Integer tolerance greater than one should succeed',
+                 goog.math.nearlyEquals(87, 85, 3));
+    }
+
+    function testStandardAngle() {
+      assertEquals(359.5, goog.math.standardAngle(-360.5));
+      assertEquals(0, goog.math.standardAngle(-360));
+      assertEquals(359.5, goog.math.standardAngle(-0.5));
+      assertEquals(0, goog.math.standardAngle(0));
+      assertEquals(0.5, goog.math.standardAngle(0.5));
+      assertEquals(0, goog.math.standardAngle(360));
+      assertEquals(1, goog.math.standardAngle(721));
+    }
+
+    function testToRadians() {
+      assertEquals(-Math.PI, goog.math.toRadians(-180));
+      assertEquals(0, goog.math.toRadians(0));
+      assertEquals(Math.PI, goog.math.toRadians(180));
+    }
+
+    function testToDegrees() {
+      assertEquals(-180, goog.math.toDegrees(-Math.PI));
+      assertEquals(0, goog.math.toDegrees(0));
+      assertEquals(180, goog.math.toDegrees(Math.PI));
+    }
+
+    function testAngleDx() {
+      assertRoughlyEquals(0, goog.math.angleDx(0, 0), 1e-10);
+      assertRoughlyEquals(0, goog.math.angleDx(90, 0), 1e-10);
+      assertRoughlyEquals(100, goog.math.angleDx(0, 100), 1e-10);
+      assertRoughlyEquals(0, goog.math.angleDx(90, 100), 1e-10);
+      assertRoughlyEquals(-100, goog.math.angleDx(180, 100), 1e-10);
+      assertRoughlyEquals(0, goog.math.angleDx(270, 100), 1e-10);
+    }
+
+    function testAngleDy() {
+      assertRoughlyEquals(0, goog.math.angleDy(0, 0), 1e-10);
+      assertRoughlyEquals(0, goog.math.angleDy(90, 0), 1e-10);
+      assertRoughlyEquals(0, goog.math.angleDy(0, 100), 1e-10);
+      assertRoughlyEquals(100, goog.math.angleDy(90, 100), 1e-10);
+      assertRoughlyEquals(0, goog.math.angleDy(180, 100), 1e-10);
+      assertRoughlyEquals(-100, goog.math.angleDy(270, 100), 1e-10);
+    }
+
+    function testAngle() {
+      assertRoughlyEquals(0, goog.math.angle(10, 10, 20, 10), 1e-10);
+      assertRoughlyEquals(90, goog.math.angle(10, 10, 10, 20), 1e-10);
+      assertRoughlyEquals(225, goog.math.angle(10, 10, 0, 0), 1e-10);
+      assertRoughlyEquals(270, goog.math.angle(10, 10, 10, 0), 1e-10);
+
+      // 0 is the conventional result, but mathematically this is undefined.
+      assertEquals(0, goog.math.angle(10, 10, 10, 10));
+    }
+
+    function testAngleDifference() {
+      assertEquals(10, goog.math.angleDifference(30, 40));
+      assertEquals(-10, goog.math.angleDifference(40, 30));
+      assertEquals(180, goog.math.angleDifference(10, 190));
+      assertEquals(180, goog.math.angleDifference(190, 10));
+      assertEquals(20, goog.math.angleDifference(350, 10));
+      assertEquals(-20, goog.math.angleDifference(10, 350));
+      assertEquals(100, goog.math.angleDifference(350, 90));
+      assertEquals(-80, goog.math.angleDifference(350, 270));
+      assertEquals(0, goog.math.angleDifference(15, 15));
+    }
+
+    function testSign() {
+      assertEquals(-1, goog.math.sign(-1));
+      assertEquals(1, goog.math.sign(1));
+      assertEquals(0, goog.math.sign(0));
+      assertEquals(0, goog.math.sign(-0));
+      assertEquals(1, goog.math.sign(0.0001));
+      assertEquals(-1, goog.math.sign(-0.0001));
+      assertEquals(-1, goog.math.sign(-Infinity));
+      assertEquals(1, goog.math.sign(Infinity));
+      assertEquals(1, goog.math.sign(3141592653589793));
+    }
+
+    function testLongestCommonSubsequence() {
+      var func = goog.math.longestCommonSubsequence;
+
+      assertArrayEquals([2], func([1,2], [2,1]));
+      assertArrayEquals([1,2], func([1,2,5], [2,1,2]));
+      assertArrayEquals([1,2,3,4,5], func([1,0,2,3,8,4,9,5], [8,1,2,4,3,6,4,5]));
+      assertArrayEquals([1,1,1,1,1], func([1,1,1,1,1], [1,1,1,1,1]));
+      assertArrayEquals([5], func([1,2,3,4,5], [5,4,3,2,1]));
+    }
+
+    function testLongestCommonSubsequenceWithCustomComparator() {
+      var func = goog.math.longestCommonSubsequence;
+
+      var compareFn = function(a, b) {
+        return a.field == b.field;
+      };
+
+      var a1 = {field: 'a1', field2: 'hello'};
+      var a2 = {field: 'a2', field2: 33};
+      var a3 = {field: 'a3'};
+      var a4 = {field: 'a3'};
+
+      assertArrayEquals([a1,a2], func([a1,a2,a3], [a3,a1,a2], compareFn));
+      assertArrayEquals([a1,a3], func([a1,a3], [a1,a4], compareFn));
+      // testing the same arrays without compare function
+      assertArrayEquals([a1], func([a1,a3], [a1,a4]));
+    }
+
+    function testLongestCommonSubsequenceWithCustomCollector() {
+      var func = goog.math.longestCommonSubsequence;
+
+      var collectorFn = function(a, b) {
+        return b;
+      };
+
+      assertArrayEquals([1,2,4,6,7], func([1,0,2,3,8,4,9,5], [8,1,2,4,3,6,4,5],
+          null, collectorFn));
+    }
+
+    function testSum() {
+      assertEquals('sum() must return 0 if there are no arguments',
+          0, goog.math.sum());
+      assertEquals('sum() must return its argument if there is only one',
+          17, goog.math.sum(17));
+      assertEquals('sum() must handle positive integers',
+          10, goog.math.sum(1, 2, 3, 4));
+      assertEquals('sum() must handle real numbers',
+          -2.5, goog.math.sum(1, -2, 3, -4.5));
+      assertTrue('sum() must return NaN if one of the arguments isn\'t numeric',
+          isNaN(goog.math.sum(1, 2, 'foo', 3)));
+    }
+
+    function testAverage() {
+      assertTrue('average() must return NaN if there are no arguments',
+          isNaN(goog.math.average()));
+      assertEquals('average() must return its argument if there is only one',
+          17, goog.math.average(17));
+      assertEquals('average() must handle positive integers',
+          3, goog.math.average(1, 2, 3, 4, 5));
+      assertEquals('average() must handle real numbers',
+          -0.625, goog.math.average(1, -2, 3, -4.5));
+      assertTrue('average() must return NaN if one of the arguments isn\'t ' +
+          'numeric', isNaN(goog.math.average(1, 2, 'foo', 3)));
+    }
+
+    function testStandardDeviation() {
+      assertEquals('standardDeviation() must return 0 if there are no samples',
+          0, goog.math.standardDeviation());
+      assertEquals('standardDeviation() must return 0 if there is only one ' +
+          'sample', 0, goog.math.standardDeviation(17));
+      assertRoughlyEquals('standardDeviation() must handle positive integers',
+          6.9282, goog.math.standardDeviation(3, 7, 7, 19),
+          0.0001);
+      assertRoughlyEquals('standardDeviation() must handle real numbers',
+          3.4660, goog.math.standardDeviation(1.23, -2.34, 3.14, -4.56),
+          0.0001);
+    }
+
+    function testIsInt() {
+      assertFalse(goog.math.isInt(12345.67));
+      assertFalse(goog.math.isInt(0.123));
+      assertFalse(goog.math.isInt(.1));
+      assertFalse(goog.math.isInt(-23.43));
+      assertFalse(goog.math.isInt(-.1));
+      assertFalse(goog.math.isInt(1e-1));
+      assertTrue(goog.math.isInt(1));
+      assertTrue(goog.math.isInt(0));
+      assertTrue(goog.math.isInt(-2));
+      assertTrue(goog.math.isInt(-2.0));
+      assertTrue(goog.math.isInt(10324231));
+      assertTrue(goog.math.isInt(1.));
+      assertTrue(goog.math.isInt(1e3));
+    }
+
+    function testIsFiniteNumber() {
+      assertFalse(goog.math.isFiniteNumber(NaN));
+      assertFalse(goog.math.isFiniteNumber(-Infinity));
+      assertFalse(goog.math.isFiniteNumber(+Infinity));
+      assertTrue(goog.math.isFiniteNumber(0));
+      assertTrue(goog.math.isFiniteNumber(1));
+      assertTrue(goog.math.isFiniteNumber(Math.PI));
+    }
+  </script>
+</body>
+</html>