RubyGems - k4compiler - Versions diffs - 0.0.1 - Mend

k4compiler 0.0.1

Files changed (1898) hide show

data/third_party/closure-library/closure/goog/vec/vec2_test.html ADDED Viewed

@@ -0,0 +1,216 @@
+<!DOCTYPE html>
+<html>
+<!--
+Copyright 2012 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.vec.Vec2</title>
+<script src="../base.js"></script>
+<script>
+  goog.require('goog.vec.Float32Array');
+  goog.require('goog.vec.Vec2');
+  goog.require('goog.testing.jsunit');
+</script>
+</head>
+<body>
+<script>
+  function testConstructor() {
+    var v = goog.vec.Vec2.createFloat32();
+    assertElementsEquals(0, v[0]);
+    assertEquals(0, v[1]);
+    assertElementsEquals([0, 0], goog.vec.Vec2.createFloat32());
+    goog.vec.Vec2.setFromValues(v, 1, 2);
+    assertElementsEquals([1, 2], v);
+    var w = goog.vec.Vec2.createFloat64();
+    assertElementsEquals(0, w[0]);
+    assertEquals(0, w[1]);
+    assertElementsEquals([0, 0], goog.vec.Vec2.createFloat64());
+    goog.vec.Vec2.setFromValues(w, 1, 2);
+    assertElementsEquals([1, 2], w);
+  }
+  function testSet() {
+    var v = goog.vec.Vec2.createFloat32();
+    goog.vec.Vec2.setFromValues(v, 1, 2);
+    assertElementsEquals([1, 2], v);
+    goog.vec.Vec2.setFromArray(v, [4, 5]);
+    assertElementsEquals([4, 5], v);
+    var w = goog.vec.Vec2.createFloat32();
+    goog.vec.Vec2.setFromValues(w, 1, 2);
+    assertElementsEquals([1, 2], w);
+    goog.vec.Vec2.setFromArray(w, [4, 5]);
+    assertElementsEquals([4, 5], w);
+  }
+  function testAdd() {
+    var v0 = goog.vec.Vec2.createFloat32FromArray([1, 2]);
+    var v1 = goog.vec.Vec2.createFloat32FromArray([4, 5]);
+    var v2 = goog.vec.Vec2.cloneFloat32(v0);
+    goog.vec.Vec2.add(v2, v1, v2);
+    assertElementsEquals([1, 2], v0);
+    assertElementsEquals([4, 5], v1);
+    assertElementsEquals([5, 7], v2);
+    goog.vec.Vec2.add(goog.vec.Vec2.add(v0, v1, v2), v0, v2);
+    assertElementsEquals([6, 9], v2);
+  }
+  function testSubtract() {
+    var v0 = goog.vec.Vec2.createFloat32FromArray([1, 2]);
+    var v1 = goog.vec.Vec2.createFloat32FromArray([4, 5]);
+    var v2 = goog.vec.Vec2.cloneFloat32(v0);
+    goog.vec.Vec2.subtract(v2, v1, v2);
+    assertElementsEquals([1, 2], v0);
+    assertElementsEquals([4, 5], v1);
+    assertElementsEquals([-3, -3], v2);
+    goog.vec.Vec2.setFromValues(v2, 0, 0, 0);
+    goog.vec.Vec2.subtract(v1, v0, v2);
+    assertElementsEquals([3, 3], v2);
+    v2 = goog.vec.Vec2.cloneFloat32(v0);
+    goog.vec.Vec2.subtract(v2, v1, v2);
+    assertElementsEquals([-3, -3], v2);
+    goog.vec.Vec2.subtract(goog.vec.Vec2.subtract(v1, v0, v2), v0, v2);
+    assertElementsEquals([2, 1], v2);
+  }
+  function testNegate() {
+    var v0 = goog.vec.Vec2.createFloat32FromArray([1, 2]);
+    var v1 = goog.vec.Vec2.createFloat32();
+    goog.vec.Vec2.negate(v0, v1);
+    assertElementsEquals([-1, -2], v1);
+    assertElementsEquals([1, 2], v0);
+    goog.vec.Vec2.negate(v0, v0);
+    assertElementsEquals([-1, -2], v0);
+  }
+  function testScale() {
+    var v0 = goog.vec.Vec2.createFloat32FromArray([1, 2]);
+    var v1 = goog.vec.Vec2.createFloat32();
+    goog.vec.Vec2.scale(v0, 4, v1);
+    assertElementsEquals([4, 8], v1);
+    assertElementsEquals([1, 2], v0);
+    goog.vec.Vec2.setFromArray(v1, v0);
+    goog.vec.Vec2.scale(v1, 5, v1);
+    assertElementsEquals([5, 10], v1);
+  }
+  function testMagnitudeSquared() {
+    var v0 = goog.vec.Vec2.createFloat32FromArray([1, 2]);
+    assertEquals(5, goog.vec.Vec2.magnitudeSquared(v0));
+  }
+  function testMagnitude() {
+    var v0 = goog.vec.Vec2.createFloat32FromArray([1, 2]);
+    assertEquals(Math.sqrt(5), goog.vec.Vec2.magnitude(v0));
+  }
+  function testNormalize() {
+    var v0 = goog.vec.Vec2.createFloat32FromArray([2, 3]);
+    var v1 = goog.vec.Vec2.createFloat32();
+    var v2 = goog.vec.Vec2.createFloat32();
+    goog.vec.Vec2.scale(
+        v0, 1 / goog.vec.Vec2.magnitude(v0), v2);
+    goog.vec.Vec2.normalize(v0, v1);
+    assertElementsEquals(v2, v1);
+    assertElementsEquals([2, 3], v0);
+    goog.vec.Vec2.setFromArray(v1, v0);
+    goog.vec.Vec2.normalize(v1, v1);
+    assertElementsEquals(v2, v1);
+  }
+  function testDot() {
+    var v0 = goog.vec.Vec2.createFloat32FromArray([1, 2]);
+    var v1 = goog.vec.Vec2.createFloat32FromArray([4, 5]);
+    assertEquals(14, goog.vec.Vec2.dot(v0, v1));
+    assertEquals(14, goog.vec.Vec2.dot(v1, v0));
+  }
+  function testDistanceSquared() {
+    var v0 = goog.vec.Vec2.createFloat32FromValues(1, 2);
+    var v1 = goog.vec.Vec2.createFloat32FromValues(1, 2);
+    assertEquals(0, goog.vec.Vec2.distanceSquared(v0, v1));
+    goog.vec.Vec2.setFromValues(v0, 1, 2);
+    goog.vec.Vec2.setFromValues(v1, -1, -2);
+    assertEquals(20, goog.vec.Vec2.distanceSquared(v0, v1));
+  }
+  function testDistance() {
+    var v0 = goog.vec.Vec2.createFloat32FromValues(1, 2);
+    var v1 = goog.vec.Vec2.createFloat32FromValues(1, 2);
+    assertEquals(0, goog.vec.Vec2.distance(v0, v1));
+    goog.vec.Vec2.setFromValues(v0, 2, 3);
+    goog.vec.Vec2.setFromValues(v1, -2, 0);
+    assertEquals(5, goog.vec.Vec2.distance(v0, v1));
+  }
+  function testDirection() {
+    var v0 = goog.vec.Vec2.createFloat32FromValues(1, 2);
+    var v1 = goog.vec.Vec2.createFloat32FromValues(1, 2);
+    var dirVec = goog.vec.Vec2.createFloat32FromValues(4, 5);
+    goog.vec.Vec2.direction(v0, v1, dirVec);
+    assertElementsEquals([0, 0], dirVec);
+    goog.vec.Vec2.setFromValues(v0, 0, 0);
+    goog.vec.Vec2.setFromValues(v1, 1, 0);
+    goog.vec.Vec2.direction(v0, v1, dirVec);
+    assertElementsEquals([1, 0], dirVec);
+    goog.vec.Vec2.setFromValues(v0, 1, 1);
+    goog.vec.Vec2.setFromValues(v1, 0, 0);
+    goog.vec.Vec2.direction(v0, v1, dirVec);
+    assertElementsRoughlyEqual(
+        [-0.707106781, -0.707106781],
+        dirVec, goog.vec.EPSILON);
+  }
+  function testLerp() {
+    var v0 = goog.vec.Vec2.createFloat32FromValues(1, 2);
+    var v1 = goog.vec.Vec2.createFloat32FromValues(10, 20);
+    var v2 = goog.vec.Vec2.cloneFloat32(v0);
+    goog.vec.Vec2.lerp(v2, v1, 0, v2);
+    assertElementsEquals([1, 2], v2);
+    goog.vec.Vec2.lerp(v2, v1, 1, v2);
+    assertElementsEquals([10, 20], v2);
+    goog.vec.Vec2.lerp(v0, v1, .5, v2);
+    assertElementsEquals([5.5, 11], v2);
+  }
+  function testEquals() {
+    var v0 = goog.vec.Vec2.createFloat32FromValues(1, 2);
+    var v1 = goog.vec.Vec2.cloneFloat32(v0);
+    assertElementsEquals(v0, v1);
+    v1[0] = 4;
+    assertFalse(goog.vec.Vec2.equals(v0, v1));
+    v1 = goog.vec.Vec2.cloneFloat32(v0);
+    v1[1] = 4;
+    assertFalse(goog.vec.Vec2.equals(v0, v1));
+  }
+</script>
+</body>

data/third_party/closure-library/closure/goog/vec/vec2d.js ADDED Viewed

@@ -0,0 +1,325 @@
+// Copyright 2013 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.
+////////////////////////// NOTE ABOUT EDITING THIS FILE ///////////////////////
+//                                                                           //
+// Any edits to this file must be applied to vec2f.js by running:            //
+//   swap_type.sh vec2d.js > vec2f.js                                        //
+//                                                                           //
+////////////////////////// NOTE ABOUT EDITING THIS FILE ///////////////////////
+/**
+ * @fileoverview Provides functions for operating on 2 element double (64bit)
+ * vectors.
+ *
+ * The last parameter will typically be the output object and an object
+ * can be both an input and output parameter to all methods except where
+ * noted.
+ *
+ * See the README for notes about the design and structure of the API
+ * (especially related to performance).
+ *
+ */
+goog.provide('goog.vec.vec2d');
+goog.provide('goog.vec.vec2d.Type');
+/** @suppress {extraRequire} */
+goog.require('goog.vec');
+/** @typedef {goog.vec.Float64} */ goog.vec.vec2d.Type;
+/**
+ * Creates a vec2d with all elements initialized to zero.
+ *
+ * @return {!goog.vec.vec2d.Type} The new vec2d.
+ */
+goog.vec.vec2d.create = function() {
+  return new Float64Array(2);
+};
+/**
+ * Initializes the vector with the given values.
+ *
+ * @param {goog.vec.vec2d.Type} vec The vector to receive the values.
+ * @param {number} v0 The value for element at index 0.
+ * @param {number} v1 The value for element at index 1.
+ * @return {!goog.vec.vec2d.Type} Return vec so that operations can be
+ *     chained together.
+ */
+goog.vec.vec2d.setFromValues = function(vec, v0, v1) {
+  vec[0] = v0;
+  vec[1] = v1;
+  return vec;
+};
+/**
+ * Initializes vec2d vec from vec2d src.
+ *
+ * @param {goog.vec.vec2d.Type} vec The destination vector.
+ * @param {goog.vec.vec2d.Type} src The source vector.
+ * @return {!goog.vec.vec2d.Type} Return vec so that operations can be
+ *     chained together.
+ */
+goog.vec.vec2d.setFromVec2d = function(vec, src) {
+  vec[0] = src[0];
+  vec[1] = src[1];
+  return vec;
+};
+/**
+ * Initializes vec2d vec from vec2f src (typed as a Float32Array to
+ * avoid circular goog.requires).
+ *
+ * @param {goog.vec.vec2d.Type} vec The destination vector.
+ * @param {Float32Array} src The source vector.
+ * @return {!goog.vec.vec2d.Type} Return vec so that operations can be
+ *     chained together.
+ */
+goog.vec.vec2d.setFromVec2f = function(vec, src) {
+  vec[0] = src[0];
+  vec[1] = src[1];
+  return vec;
+};
+/**
+ * Initializes vec2d vec from Array src.
+ *
+ * @param {goog.vec.vec2d.Type} vec The destination vector.
+ * @param {Array.<number>} src The source vector.
+ * @return {!goog.vec.vec2d.Type} Return vec so that operations can be
+ *     chained together.
+ */
+goog.vec.vec2d.setFromArray = function(vec, src) {
+  vec[0] = src[0];
+  vec[1] = src[1];
+  return vec;
+};
+/**
+ * Performs a component-wise addition of vec0 and vec1 together storing the
+ * result into resultVec.
+ *
+ * @param {goog.vec.vec2d.Type} vec0 The first addend.
+ * @param {goog.vec.vec2d.Type} vec1 The second addend.
+ * @param {goog.vec.vec2d.Type} resultVec The vector to
+ *     receive the result. May be vec0 or vec1.
+ * @return {!goog.vec.vec2d.Type} Return resultVec so that operations can be
+ *     chained together.
+ */
+goog.vec.vec2d.add = function(vec0, vec1, resultVec) {
+  resultVec[0] = vec0[0] + vec1[0];
+  resultVec[1] = vec0[1] + vec1[1];
+  return resultVec;
+};
+/**
+ * Performs a component-wise subtraction of vec1 from vec0 storing the
+ * result into resultVec.
+ *
+ * @param {goog.vec.vec2d.Type} vec0 The minuend.
+ * @param {goog.vec.vec2d.Type} vec1 The subtrahend.
+ * @param {goog.vec.vec2d.Type} resultVec The vector to
+ *     receive the result. May be vec0 or vec1.
+ * @return {!goog.vec.vec2d.Type} Return resultVec so that operations can be
+ *     chained together.
+ */
+goog.vec.vec2d.subtract = function(vec0, vec1, resultVec) {
+  resultVec[0] = vec0[0] - vec1[0];
+  resultVec[1] = vec0[1] - vec1[1];
+  return resultVec;
+};
+/**
+ * Negates vec0, storing the result into resultVec.
+ *
+ * @param {goog.vec.vec2d.Type} vec0 The vector to negate.
+ * @param {goog.vec.vec2d.Type} resultVec The vector to
+ *     receive the result. May be vec0.
+ * @return {!goog.vec.vec2d.Type} Return resultVec so that operations can be
+ *     chained together.
+ */
+goog.vec.vec2d.negate = function(vec0, resultVec) {
+  resultVec[0] = -vec0[0];
+  resultVec[1] = -vec0[1];
+  return resultVec;
+};
+/**
+ * Multiplies each component of vec0 with scalar storing the product into
+ * resultVec.
+ *
+ * @param {goog.vec.vec2d.Type} vec0 The source vector.
+ * @param {number} scalar The value to multiply with each component of vec0.
+ * @param {goog.vec.vec2d.Type} resultVec The vector to
+ *     receive the result. May be vec0.
+ * @return {!goog.vec.vec2d.Type} Return resultVec so that operations can be
+ *     chained together.
+ */
+goog.vec.vec2d.scale = function(vec0, scalar, resultVec) {
+  resultVec[0] = vec0[0] * scalar;
+  resultVec[1] = vec0[1] * scalar;
+  return resultVec;
+};
+/**
+ * Returns the magnitudeSquared of the given vector.
+ *
+ * @param {goog.vec.vec2d.Type} vec0 The vector.
+ * @return {number} The magnitude of the vector.
+ */
+goog.vec.vec2d.magnitudeSquared = function(vec0) {
+  var x = vec0[0], y = vec0[1];
+  return x * x + y * y;
+};
+/**
+ * Returns the magnitude of the given vector.
+ *
+ * @param {goog.vec.vec2d.Type} vec0 The vector.
+ * @return {number} The magnitude of the vector.
+ */
+goog.vec.vec2d.magnitude = function(vec0) {
+  var x = vec0[0], y = vec0[1];
+  return Math.sqrt(x * x + y * y);
+};
+/**
+ * Normalizes the given vector storing the result into resultVec.
+ *
+ * @param {goog.vec.vec2d.Type} vec0 The vector to normalize.
+ * @param {goog.vec.vec2d.Type} resultVec The vector to
+ *     receive the result. May be vec0.
+ * @return {!goog.vec.vec2d.Type} Return resultVec so that operations can be
+ *     chained together.
+ */
+goog.vec.vec2d.normalize = function(vec0, resultVec) {
+  var x = vec0[0], y = vec0[1];
+  var ilen = 1 / Math.sqrt(x * x + y * y);
+  resultVec[0] = x * ilen;
+  resultVec[1] = y * ilen;
+  return resultVec;
+};
+/**
+ * Returns the scalar product of vectors vec0 and vec1.
+ *
+ * @param {goog.vec.vec2d.Type} vec0 The first vector.
+ * @param {goog.vec.vec2d.Type} vec1 The second vector.
+ * @return {number} The scalar product.
+ */
+goog.vec.vec2d.dot = function(vec0, vec1) {
+  return vec0[0] * vec1[0] + vec0[1] * vec1[1];
+};
+/**
+ * Returns the squared distance between two points.
+ *
+ * @param {goog.vec.vec2d.Type} vec0 First point.
+ * @param {goog.vec.vec2d.Type} vec1 Second point.
+ * @return {number} The squared distance between the points.
+ */
+goog.vec.vec2d.distanceSquared = function(vec0, vec1) {
+  var x = vec0[0] - vec1[0];
+  var y = vec0[1] - vec1[1];
+  return x * x + y * y;
+};
+/**
+ * Returns the distance between two points.
+ *
+ * @param {goog.vec.vec2d.Type} vec0 First point.
+ * @param {goog.vec.vec2d.Type} vec1 Second point.
+ * @return {number} The distance between the points.
+ */
+goog.vec.vec2d.distance = function(vec0, vec1) {
+  return Math.sqrt(goog.vec.vec2d.distanceSquared(vec0, vec1));
+};
+/**
+ * Returns a unit vector pointing from one point to another.
+ * If the input points are equal then the result will be all zeros.
+ *
+ * @param {goog.vec.vec2d.Type} vec0 Origin point.
+ * @param {goog.vec.vec2d.Type} vec1 Target point.
+ * @param {goog.vec.vec2d.Type} resultVec The vector to receive the
+ *     results (may be vec0 or vec1).
+ * @return {!goog.vec.vec2d.Type} Return resultVec so that operations can be
+ *     chained together.
+ */
+goog.vec.vec2d.direction = function(vec0, vec1, resultVec) {
+  var x = vec1[0] - vec0[0];
+  var y = vec1[1] - vec0[1];
+  var d = Math.sqrt(x * x + y * y);
+  if (d) {
+    d = 1 / d;
+    resultVec[0] = x * d;
+    resultVec[1] = y * d;
+  } else {
+    resultVec[0] = resultVec[1] = 0;
+  }
+  return resultVec;
+};
+/**
+ * Linearly interpolate from vec0 to vec1 according to f. The value of f should
+ * be in the range [0..1] otherwise the results are undefined.
+ *
+ * @param {goog.vec.vec2d.Type} vec0 The first vector.
+ * @param {goog.vec.vec2d.Type} vec1 The second vector.
+ * @param {number} f The interpolation factor.
+ * @param {goog.vec.vec2d.Type} resultVec The vector to receive the
+ *     results (may be vec0 or vec1).
+ * @return {!goog.vec.vec2d.Type} Return resultVec so that operations can be
+ *     chained together.
+ */
+goog.vec.vec2d.lerp = function(vec0, vec1, f, resultVec) {
+  var x = vec0[0], y = vec0[1];
+  resultVec[0] = (vec1[0] - x) * f + x;
+  resultVec[1] = (vec1[1] - y) * f + y;
+  return resultVec;
+};
+/**
+ * Returns true if the components of vec0 are equal to the components of vec1.
+ *
+ * @param {goog.vec.vec2d.Type} vec0 The first vector.
+ * @param {goog.vec.vec2d.Type} vec1 The second vector.
+ * @return {boolean} True if the vectors are equal, false otherwise.
+ */
+goog.vec.vec2d.equals = function(vec0, vec1) {
+  return vec0.length == vec1.length &&
+      vec0[0] == vec1[0] && vec0[1] == vec1[1];
+};