RubyGems - middleman-wizard-template - Versions diffs - 1.0.2 → 1.0.3 - Mend

middleman-wizard-template 1.0.2 → 1.0.3

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (25) hide show

checksums.yaml ADDED Viewed

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 35b547b31fb7f432f69044f4947b2be82ad820c0
+  data.tar.gz: ac55e5b1572518f794db9d04a6486455c3c1c4cb
+SHA512:
+  metadata.gz: 251f7f5f63a92d3bb4033c3428aa6174693635ca1705d05562221ab3503224f31a36e54ff57dc355d5e5644955425e84210d6061e318a49b36a3e3141c1f9fed
+  data.tar.gz: 567e046a9b67d808554425c3dd737bfa2843c63c54cfe4c8b81b16611e322f295231a3e3336e93597a0a5da444b22145e47598161e629a6346e627c21a35e1c0

data/lib/middleman-wizard-template/template/source/index.html.erb CHANGED Viewed

@@ -1,89 +1 @@
-<!DOCTYPE html>
-<html class="google" lang="en" class="no-js">
-<head>
-  <script>
-(function(H){H.className=H.className.replace(/\bgoogle\b/,'google-js')})(document.documentElement)
-  </script>
-  <meta charset="utf-8">
-  <meta content="initial-scale=1, minimum-scale=1, width=device-width" name="viewport">
-  <title>
-    Site – Google
-  </title>
-  <script src="http://www.google.com/js/google.js">
-</script>
-  <!--script>
-new gweb.analytics.AutoTrack({profile:"UA-22442000-1",trackQueryParams:"true"});
-  </script-->
-  <link href="http://fonts.googleapis.com/css?family=Open+Sans:300,400,600,700&amp;lang=en" rel=
-  "stylesheet">
-  <%= stylesheet_link_tag :default %>
-  <%= javascript_include_tag :modernizr %>
-  <%= stylesheet_link_tag :site %>
-  <script src="/closure/library/closure/goog/base.js"></script>
-</head>
-<body>
-<div class="maia-header" id="maia-header" role="banner">
-  <div class="maia-aux">
-    <h1>
-      <a href="/" target="_blank"><img alt="Google" src="//www.google.com/images/logos/google_logo_41.png"></a>
-    </h1>
-    <h2>
-      <a href="../">Site</a>
-    </h2>
-  </div>
-</div>
-<div id="maia-main" role="main">
-</div>
-<div id="maia-signature"></div>
-<script type="text/javascript" src="https://www.google.com/jsapi"></script>
-<%= javascript_include_tag :site %>
-<script>ww.init();</script>
-<div class="maia-footer" id="maia-footer">
-  <div id="maia-footer-local">
-    <div class="maia-aux">
-      <p>
-        <a data-g-event="Footer Nav: Press" href="../press/">Press Center</a> |
-        <a data-g-event="Footer Nav: For educators" href="../searcheducation/index.html">For
-        Educators</a>
-      </p>
-      <div class="plus">
-        <div class="g-plusone" data-href="http://www.google.com/insidesearch/" data-size=
-        "small"></div>
-      </div>
-    </div>
-  </div>
-  <div id="maia-footer-global">
-    <div class="maia-aux">
-      <ul>
-        <li>
-          <a href="/" target="_blank">Google</a>
-        </li>
-        <li>
-          <a href="/intl/en/about/">About Google</a>
-        </li>
-        <li>
-          <a href="/intl/en/policies/">Privacy &amp; Terms</a>
-        </li>
-      </ul>
-    </div>
-  </div>
-</div>
-<!--script>
-window.___gcfg = {lang: 'en'};
-  (function() {
-    var po = document.createElement('script'); po.type = 'text/javascript'; po.async = true;
-    po.src = 'https://apis.google.com/js/plusone.js';
-    var s = document.getElementsByTagName('script')[0]; s.parentNode.insertBefore(po, s);
-  })();
-</script--> <script src="http://www.google.com/js/maia.js"></script>
-</body>
-</html>
+<h1>Site Name</h1>

data/lib/middleman-wizard-template/template/source/javascripts/_lib/ww/Matrix.js ADDED Viewed

@@ -0,0 +1,449 @@
+goog.provide('Sylvester.Matrix');
+Sylvester.Matrix = function() {};
+Sylvester.Matrix.create = function(elements) {
+  var M = new Sylvester.Matrix();
+  return M.setElements(elements);
+};
+var $M = Sylvester.Matrix.create;
+Sylvester.Matrix.I = function(n) {
+  var els = [], i = n, j;
+  while (i--) { j = n;
+    els[i] = [];
+    while (j--) {
+      els[i][j] = (i === j) ? 1 : 0;
+    }
+  }
+  return Sylvester.Matrix.create(els);
+};
+Sylvester.Matrix.Diagonal = function(elements) {
+  var i = elements.length;
+  var M = Sylvester.Matrix.I(i);
+  while (i--) {
+    M.elements[i][i] = elements[i];
+  }
+  return M;
+};
+Sylvester.Matrix.Rotation = function(theta, a) {
+  if (!a) {
+    return Sylvester.Matrix.create([
+      [Math.cos(theta),  -Math.sin(theta)],
+      [Math.sin(theta),   Math.cos(theta)]
+    ]);
+  }
+  var axis = a.dup();
+  if (axis.elements.length !== 3) { return null; }
+  var mod = axis.modulus();
+  var x = axis.elements[0]/mod, y = axis.elements[1]/mod, z = axis.elements[2]/mod;
+  var s = Math.sin(theta), c = Math.cos(theta), t = 1 - c;
+  // Formula derived here: http://www.gamedev.net/reference/articles/article1199.asp
+  // That proof rotates the co-ordinate system so theta becomes -theta and sin
+  // becomes -sin here.
+  return Sylvester.Matrix.create([
+    [ t*x*x + c, t*x*y - s*z, t*x*z + s*y ],
+    [ t*x*y + s*z, t*y*y + c, t*y*z - s*x ],
+    [ t*x*z - s*y, t*y*z + s*x, t*z*z + c ]
+  ]);
+};
+Sylvester.Matrix.RotationX = function(t) {
+  var c = Math.cos(t), s = Math.sin(t);
+  return Sylvester.Matrix.create([
+    [  1,  0,  0 ],
+    [  0,  c, -s ],
+    [  0,  s,  c ]
+  ]);
+};
+Sylvester.Matrix.RotationY = function(t) {
+  var c = Math.cos(t), s = Math.sin(t);
+  return Sylvester.Matrix.create([
+    [  c,  0,  s ],
+    [  0,  1,  0 ],
+    [ -s,  0,  c ]
+  ]);
+};
+Sylvester.Matrix.RotationZ = function(t) {
+  var c = Math.cos(t), s = Math.sin(t);
+  return Sylvester.Matrix.create([
+    [  c, -s,  0 ],
+    [  s,  c,  0 ],
+    [  0,  0,  1 ]
+  ]);
+};
+Sylvester.Matrix.Random = function(n, m) {
+  return Sylvester.Matrix.Zero(n, m).map(
+    function() { return Math.random(); }
+  );
+};
+Sylvester.Matrix.Zero = function(n, m) {
+  var els = [], i = n, j;
+  while (i--) { j = m;
+    els[i] = [];
+    while (j--) {
+      els[i][j] = 0;
+    }
+  }
+  return Sylvester.Matrix.create(els);
+};
+Sylvester.Matrix.prototype = {
+  e: function(i,j) {
+    if (i < 1 || i > this.elements.length || j < 1 || j > this.elements[0].length) { return null; }
+    return this.elements[i-1][j-1];
+  },
+  row: function(i) {
+    if (i > this.elements.length) { return null; }
+    return Sylvester.Vector.create(this.elements[i-1]);
+  },
+  col: function(j) {
+    if (this.elements.length === 0) { return null; }
+    if (j > this.elements[0].length) { return null; }
+    var col = [], n = this.elements.length;
+    for (var i = 0; i < n; i++) { col.push(this.elements[i][j-1]); }
+    return Sylvester.Vector.create(col);
+  },
+  dimensions: function() {
+    var cols = (this.elements.length === 0) ? 0 : this.elements[0].length;
+    return {rows: this.elements.length, cols: cols};
+  },
+  rows: function() {
+    return this.elements.length;
+  },
+  cols: function() {
+    if (this.elements.length === 0) { return 0; }
+    return this.elements[0].length;
+  },
+  eql: function(matrix) {
+    var M = matrix.elements || matrix;
+    if (!M[0] || typeof(M[0][0]) === 'undefined') { M = Sylvester.Matrix.create(M).elements; }
+    if (this.elements.length === 0 || M.length === 0) {
+      return this.elements.length === M.length;
+    }
+    if (this.elements.length !== M.length) { return false; }
+    if (this.elements[0].length !== M[0].length) { return false; }
+    var i = this.elements.length, nj = this.elements[0].length, j;
+    while (i--) { j = nj;
+      while (j--) {
+        if (Math.abs(this.elements[i][j] - M[i][j]) > Sylvester.precision) { return false; }
+      }
+    }
+    return true;
+  },
+  dup: function() {
+    return Sylvester.Matrix.create(this.elements);
+  },
+  map: function(fn, context) {
+    if (this.elements.length === 0) { return Sylvester.Matrix.create([]); }
+    var els = [], i = this.elements.length, nj = this.elements[0].length, j;
+    while (i--) { j = nj;
+      els[i] = [];
+      while (j--) {
+        els[i][j] = fn.call(context, this.elements[i][j], i + 1, j + 1);
+      }
+    }
+    return Sylvester.Matrix.create(els);
+  },
+  isSameSizeAs: function(matrix) {
+    var M = matrix.elements || matrix;
+    if (typeof(M[0][0]) === 'undefined') { M = Sylvester.Matrix.create(M).elements; }
+    if (this.elements.length === 0) { return M.length === 0; }
+    return (this.elements.length === M.length &&
+        this.elements[0].length === M[0].length);
+  },
+  add: function(matrix) {
+    if (this.elements.length === 0) return this.map(function(x) { return x });
+    var M = matrix.elements || matrix;
+    if (typeof(M[0][0]) === 'undefined') { M = Sylvester.Matrix.create(M).elements; }
+    if (!this.isSameSizeAs(M)) { return null; }
+    return this.map(function(x, i, j) { return x + M[i-1][j-1]; });
+  },
+  subtract: function(matrix) {
+    if (this.elements.length === 0) return this.map(function(x) { return x });
+    var M = matrix.elements || matrix;
+    if (typeof(M[0][0]) === 'undefined') { M = Sylvester.Matrix.create(M).elements; }
+    if (!this.isSameSizeAs(M)) { return null; }
+    return this.map(function(x, i, j) { return x - M[i-1][j-1]; });
+  },
+  canMultiplyFromLeft: function(matrix) {
+    if (this.elements.length === 0) { return false; }
+    var M = matrix.elements || matrix;
+    if (typeof(M[0][0]) === 'undefined') { M = Sylvester.Matrix.create(M).elements; }
+    // this.columns should equal matrix.rows
+    return (this.elements[0].length === M.length);
+  },
+  multiply: function(matrix) {
+    if (this.elements.length === 0) { return null; }
+    if (!matrix.elements) {
+      return this.map(function(x) { return x * matrix; });
+    }
+    var returnVector = matrix.modulus ? true : false;
+    var M = matrix.elements || matrix;
+    if (typeof(M[0][0]) === 'undefined') { M = Sylvester.Matrix.create(M).elements; }
+    if (!this.canMultiplyFromLeft(M)) { return null; }
+    var i = this.elements.length, nj = M[0].length, j;
+    var cols = this.elements[0].length, c, elements = [], sum;
+    while (i--) { j = nj;
+      elements[i] = [];
+      while (j--) { c = cols;
+        sum = 0;
+        while (c--) {
+          sum += this.elements[i][c] * M[c][j];
+        }
+        elements[i][j] = sum;
+      }
+    }
+    var M = Sylvester.Matrix.create(elements);
+    return returnVector ? M.col(1) : M;
+  },
+  minor: function(a, b, c, d) {
+    if (this.elements.length === 0) { return null; }
+    var elements = [], ni = c, i, nj, j;
+    var rows = this.elements.length, cols = this.elements[0].length;
+    while (ni--) { i = c - ni - 1;
+      elements[i] = [];
+      nj = d;
+      while (nj--) { j = d - nj - 1;
+        elements[i][j] = this.elements[(a+i-1)%rows][(b+j-1)%cols];
+      }
+    }
+    return Sylvester.Matrix.create(elements);
+  },
+  transpose: function() {
+    if (this.elements.length === 0) return Sylvester.Matrix.create([]);
+    var rows = this.elements.length, i, cols = this.elements[0].length, j;
+    var elements = [], i = cols;
+    while (i--) { j = rows;
+      elements[i] = [];
+      while (j--) {
+        elements[i][j] = this.elements[j][i];
+      }
+    }
+    return Sylvester.Matrix.create(elements);
+  },
+  isSquare: function() {
+    var cols = (this.elements.length === 0) ? 0 : this.elements[0].length;
+    return (this.elements.length === cols);
+  },
+  max: function() {
+    if (this.elements.length === 0) { return null; }
+    var m = 0, i = this.elements.length, nj = this.elements[0].length, j;
+    while (i--) { j = nj;
+      while (j--) {
+        if (Math.abs(this.elements[i][j]) > Math.abs(m)) { m = this.elements[i][j]; }
+      }
+    }
+    return m;
+  },
+  indexOf: function(x) {
+    if (this.elements.length === 0) { return null; }
+    var index = null, ni = this.elements.length, i, nj = this.elements[0].length, j;
+    for (i = 0; i < ni; i++) {
+      for (j = 0; j < nj; j++) {
+        if (this.elements[i][j] === x) { return {i: i+1, j: j+1}; }
+      }
+    }
+    return null;
+  },
+  diagonal: function() {
+    if (!this.isSquare) { return null; }
+    var els = [], n = this.elements.length;
+    for (var i = 0; i < n; i++) {
+      els.push(this.elements[i][i]);
+    }
+    return Sylvester.Vector.create(els);
+  },
+  toRightTriangular: function() {
+    if (this.elements.length === 0) return Sylvester.Matrix.create([]);
+    var M = this.dup(), els;
+    var n = this.elements.length, i, j, np = this.elements[0].length, p;
+    for (i = 0; i < n; i++) {
+      if (M.elements[i][i] === 0) {
+        for (j = i + 1; j < n; j++) {
+          if (M.elements[j][i] !== 0) {
+            els = [];
+            for (p = 0; p < np; p++) { els.push(M.elements[i][p] + M.elements[j][p]); }
+            M.elements[i] = els;
+            break;
+          }
+        }
+      }
+      if (M.elements[i][i] !== 0) {
+        for (j = i + 1; j < n; j++) {
+          var multiplier = M.elements[j][i] / M.elements[i][i];
+          els = [];
+          for (p = 0; p < np; p++) {
+            // Elements with column numbers up to an including the number of the
+            // row that we're subtracting can safely be set straight to zero,
+            // since that's the point of this routine and it avoids having to
+            // loop over and correct rounding errors later
+            els.push(p <= i ? 0 : M.elements[j][p] - M.elements[i][p] * multiplier);
+          }
+          M.elements[j] = els;
+        }
+      }
+    }
+    return M;
+  },
+  determinant: function() {
+    if (this.elements.length === 0) { return 1; }
+    if (!this.isSquare()) { return null; }
+    var M = this.toRightTriangular();
+    var det = M.elements[0][0], n = M.elements.length;
+    for (var i = 1; i < n; i++) {
+      det = det * M.elements[i][i];
+    }
+    return det;
+  },
+  isSingular: function() {
+    return (this.isSquare() && this.determinant() === 0);
+  },
+  trace: function() {
+    if (this.elements.length === 0) { return 0; }
+    if (!this.isSquare()) { return null; }
+    var tr = this.elements[0][0], n = this.elements.length;
+    for (var i = 1; i < n; i++) {
+      tr += this.elements[i][i];
+    }
+    return tr;
+  },
+  rank: function() {
+    if (this.elements.length === 0) { return 0; }
+    var M = this.toRightTriangular(), rank = 0;
+    var i = this.elements.length, nj = this.elements[0].length, j;
+    while (i--) { j = nj;
+      while (j--) {
+        if (Math.abs(M.elements[i][j]) > Sylvester.precision) { rank++; break; }
+      }
+    }
+    return rank;
+  },
+  augment: function(matrix) {
+    if (this.elements.length === 0) { return this.dup(); }
+    var M = matrix.elements || matrix;
+    if (typeof(M[0][0]) === 'undefined') { M = Sylvester.Matrix.create(M).elements; }
+    var T = this.dup(), cols = T.elements[0].length;
+    var i = T.elements.length, nj = M[0].length, j;
+    if (i !== M.length) { return null; }
+    while (i--) { j = nj;
+      while (j--) {
+        T.elements[i][cols + j] = M[i][j];
+      }
+    }
+    return T;
+  },
+  inverse: function() {
+    if (this.elements.length === 0) { return null; }
+    if (!this.isSquare() || this.isSingular()) { return null; }
+    var n = this.elements.length, i= n, j;
+    var M = this.augment(Sylvester.Matrix.I(n)).toRightTriangular();
+    var np = M.elements[0].length, p, els, divisor;
+    var inverse_elements = [], new_element;
+    // Sylvester.Matrix is non-singular so there will be no zeros on the
+    // diagonal. Cycle through rows from last to first.
+    while (i--) {
+      // First, normalise diagonal elements to 1
+      els = [];
+      inverse_elements[i] = [];
+      divisor = M.elements[i][i];
+      for (p = 0; p < np; p++) {
+        new_element = M.elements[i][p] / divisor;
+        els.push(new_element);
+        // Shuffle off the current row of the right hand side into the results
+        // array as it will not be modified by later runs through this loop
+        if (p >= n) { inverse_elements[i].push(new_element); }
+      }
+      M.elements[i] = els;
+      // Then, subtract this row from those above it to give the identity matrix
+      // on the left hand side
+      j = i;
+      while (j--) {
+        els = [];
+        for (p = 0; p < np; p++) {
+          els.push(M.elements[j][p] - M.elements[i][p] * M.elements[j][i]);
+        }
+        M.elements[j] = els;
+      }
+    }
+    return Sylvester.Matrix.create(inverse_elements);
+  },
+  round: function() {
+    return this.map(function(x) { return Math.round(x); });
+  },
+  snapTo: function(x) {
+    return this.map(function(p) {
+      return (Math.abs(p - x) <= Sylvester.precision) ? x : p;
+    });
+  },
+  inspect: function() {
+    var matrix_rows = [];
+    var n = this.elements.length;
+    if (n === 0) return '[]';
+    for (var i = 0; i < n; i++) {
+      matrix_rows.push(Sylvester.Vector.create(this.elements[i]).inspect());
+    }
+    return matrix_rows.join('\n');
+  },
+  setElements: function(els) {
+    var i, j, elements = els.elements || els;
+    if (elements[0] && typeof(elements[0][0]) !== 'undefined') {
+      i = elements.length;
+      this.elements = [];
+      while (i--) { j = elements[i].length;
+        this.elements[i] = [];
+        while (j--) {
+          this.elements[i][j] = elements[i][j];
+        }
+      }
+      return this;
+    }
+    var n = elements.length;
+    this.elements = [];
+    for (i = 0; i < n; i++) {
+      this.elements.push([elements[i]]);
+    }
+    return this;
+  }
+};
+Sylvester.Matrix.prototype.toUpperTriangular = Sylvester.Matrix.prototype.toRightTriangular;
+Sylvester.Matrix.prototype.det = Sylvester.Matrix.prototype.determinant;
+Sylvester.Matrix.prototype.tr = Sylvester.Matrix.prototype.trace;
+Sylvester.Matrix.prototype.rk = Sylvester.Matrix.prototype.rank;
+Sylvester.Matrix.prototype.inv = Sylvester.Matrix.prototype.inverse;
+Sylvester.Matrix.prototype.x = Sylvester.Matrix.prototype.multiply;