rubyvis 0.6.0 → 0.6.1

data/vendor/protovis/src/layout/Bullet.js

@@ -1,164 +0,0 @@
-// ranges (bad, satisfactory, good)
-// measures (actual, forecast)
-// markers (previous, goal)
-
-/*
- * Chart design based on the recommendations of Stephen Few. Implementation
- * based on the work of Clint Ivy, Jamie Love, and Jason Davies.
- * http://projects.instantcognition.com/protovis/bulletchart/
- */
-
-/**
- * Constructs a new, empty bullet layout. Layouts are not typically constructed
- * directly; instead, they are added to an existing panel via
- * {@link pv.Mark#add}.
- *
- * @class
- * @extends pv.Layout
- */
-pv.Layout.Bullet = function() {
-  pv.Layout.call(this);
-  var that = this,
-      buildImplied = that.buildImplied,
-      scale = that.x = pv.Scale.linear(),
-      orient,
-      horizontal,
-      rangeColor,
-      measureColor,
-      x;
-
-  /** @private Cache layout state to optimize properties. */
-  this.buildImplied = function(s) {
-    buildImplied.call(this, x = s);
-    orient = s.orient;
-    horizontal = /^left|right$/.test(orient);
-    rangeColor = pv.ramp("#bbb", "#eee")
-        .domain(0, Math.max(1, x.ranges.length - 1));
-    measureColor = pv.ramp("steelblue", "lightsteelblue")
-        .domain(0, Math.max(1, x.measures.length - 1));
-  };
-
-  /**
-   * The range prototype.
-   *
-   * @type pv.Mark
-   * @name pv.Layout.Bullet.prototype.range
-   */
-  (this.range = new pv.Mark())
-      .data(function() { return x.ranges; })
-      .reverse(true)
-      .left(function() { return orient == "left" ? 0 : null; })
-      .top(function() { return orient == "top" ? 0 : null; })
-      .right(function() { return orient == "right" ? 0 : null; })
-      .bottom(function() { return orient == "bottom" ? 0 : null; })
-      .width(function(d) { return horizontal ? scale(d) : null; })
-      .height(function(d) { return horizontal ? null : scale(d); })
-      .fillStyle(function() { return rangeColor(this.index); })
-      .antialias(false)
-      .parent = that;
-
-  /**
-   * The measure prototype.
-   *
-   * @type pv.Mark
-   * @name pv.Layout.Bullet.prototype.measure
-   */
-  (this.measure = new pv.Mark())
-      .extend(this.range)
-      .data(function() { return x.measures; })
-      .left(function() { return orient == "left" ? 0 : horizontal ? null : this.parent.width() / 3.25; })
-      .top(function() { return orient == "top" ? 0 : horizontal ? this.parent.height() / 3.25 : null; })
-      .right(function() { return orient == "right" ? 0 : horizontal ? null : this.parent.width() / 3.25; })
-      .bottom(function() { return orient == "bottom" ? 0 : horizontal ? this.parent.height() / 3.25 : null; })
-      .fillStyle(function() { return measureColor(this.index); })
-      .parent = that;
-
-  /**
-   * The marker prototype.
-   *
-   * @type pv.Mark
-   * @name pv.Layout.Bullet.prototype.marker
-   */
-  (this.marker = new pv.Mark())
-      .data(function() { return x.markers; })
-      .left(function(d) { return orient == "left" ? scale(d) : horizontal ? null : this.parent.width() / 2; })
-      .top(function(d) { return orient == "top" ? scale(d) : horizontal ? this.parent.height() / 2 : null; })
-      .right(function(d) { return orient == "right" ? scale(d) : null; })
-      .bottom(function(d) { return orient == "bottom" ? scale(d) : null; })
-      .strokeStyle("black")
-      .shape("bar")
-      .shapeAngle(function() { return horizontal ? 0 : Math.PI / 2; })
-      .parent = that;
-
-  (this.tick = new pv.Mark())
-      .data(function() { return scale.ticks(7); })
-      .left(function(d) { return orient == "left" ? scale(d) : null; })
-      .top(function(d) { return orient == "top" ? scale(d) : null; })
-      .right(function(d) { return orient == "right" ? scale(d) : horizontal ? null : -6; })
-      .bottom(function(d) { return orient == "bottom" ? scale(d) : horizontal ? -8 : null; })
-      .height(function() { return horizontal ? 6 : null; })
-      .width(function() { return horizontal ? null : 6; })
-      .parent = that;
-};
-
-pv.Layout.Bullet.prototype = pv.extend(pv.Layout)
-    .property("orient", String) // left, right, top, bottom
-    .property("ranges")
-    .property("markers")
-    .property("measures")
-    .property("maximum", Number);
-
-/**
- * Default properties for bullet layouts.
- *
- * @type pv.Layout.Bullet
- */
-pv.Layout.Bullet.prototype.defaults = new pv.Layout.Bullet()
-    .extend(pv.Layout.prototype.defaults)
-    .orient("left")
-    .ranges([])
-    .markers([])
-    .measures([]);
-
-/**
- * The orientation.
- *
- * @type string
- * @name pv.Layout.Bullet.prototype.orient
- */
-
-/**
- * The array of range values.
- *
- * @type array
- * @name pv.Layout.Bullet.prototype.ranges
- */
-
-/**
- * The array of marker values.
- *
- * @type array
- * @name pv.Layout.Bullet.prototype.markers
- */
-
-/**
- * The array of measure values.
- *
- * @type array
- * @name pv.Layout.Bullet.prototype.measures
- */
-
-/**
- * Optional; the maximum range value.
- *
- * @type number
- * @name pv.Layout.Bullet.prototype.maximum
- */
-
-/** @private */
-pv.Layout.Bullet.prototype.buildImplied = function(s) {
-  pv.Layout.prototype.buildImplied.call(this, s);
-  var size = this.parent[/^left|right$/.test(s.orient) ? "width" : "height"]();
-  s.maximum = s.maximum || pv.max([].concat(s.ranges, s.markers, s.measures));
-  this.x.domain(0, s.maximum).range(0, size);
-};

data/vendor/protovis/src/layout/Cluster.js

@@ -1,205 +0,0 @@
-/**
- * Constructs a new, empty cluster layout. Layouts are not typically
- * constructed directly; instead, they are added to an existing panel via
- * {@link pv.Mark#add}.
- *
- * @class Implements a hierarchical layout using the cluster (or dendrogram)
- * algorithm. This layout provides both node-link and space-filling
- * implementations of cluster diagrams. In many ways it is similar to
- * {@link pv.Layout.Partition}, except that leaf nodes are positioned at maximum
- * depth, and the depth of internal nodes is based on their distance from their
- * deepest descendant, rather than their distance from the root.
- *
- * <p>The cluster layout supports a "group" property, which if true causes
- * siblings to be positioned closer together than unrelated nodes at the same
- * depth. Unlike the partition layout, this layout does not support dynamic
- * sizing for leaf nodes; all leaf nodes are the same size.
- *
- * <p>For more details on how to use this layout, see
- * {@link pv.Layout.Hierarchy}.
- *
- * @see pv.Layout.Cluster.Fill
- * @extends pv.Layout.Hierarchy
- */
-pv.Layout.Cluster = function() {
-  pv.Layout.Hierarchy.call(this);
-  var interpolate, // cached interpolate
-      buildImplied = this.buildImplied;
-
-  /** @private Cache layout state to optimize properties. */
-  this.buildImplied = function(s) {
-    buildImplied.call(this, s);
-    interpolate
-        = /^(top|bottom)$/.test(s.orient) ? "step-before"
-        : /^(left|right)$/.test(s.orient) ? "step-after"
-        : "linear";
-  };
-
-  this.link.interpolate(function() { return interpolate; });
-};
-
-pv.Layout.Cluster.prototype = pv.extend(pv.Layout.Hierarchy)
-    .property("group", Number)
-    .property("orient", String)
-    .property("innerRadius", Number)
-    .property("outerRadius", Number);
-
-/**
- * The group parameter; defaults to 0, disabling grouping of siblings. If this
- * parameter is set to a positive number (or true, which is equivalent to 1),
- * then additional space will be allotted between sibling groups. In other
- * words, siblings (nodes that share the same parent) will be positioned more
- * closely than nodes at the same depth that do not share a parent.
- *
- * @type number
- * @name pv.Layout.Cluster.prototype.group
- */
-
-/**
- * The orientation. The default orientation is "top", which means that the root
- * node is placed on the top edge, leaf nodes appear on the bottom edge, and
- * internal nodes are in-between. The following orientations are supported:<ul>
- *
- * <li>left - left-to-right.
- * <li>right - right-to-left.
- * <li>top - top-to-bottom.
- * <li>bottom - bottom-to-top.
- * <li>radial - radially, with the root at the center.</ul>
- *
- * @type string
- * @name pv.Layout.Cluster.prototype.orient
- */
-
-/**
- * The inner radius; defaults to 0. This property applies only to radial
- * orientations, and can be used to compress the layout radially. Note that for
- * the node-link implementation, the root node is always at the center,
- * regardless of the value of this property; this property only affects internal
- * and leaf nodes. For the space-filling implementation, a non-zero value of
- * this property will result in the root node represented as a ring rather than
- * a circle.
- *
- * @type number
- * @name pv.Layout.Cluster.prototype.innerRadius
- */
-
-/**
- * The outer radius; defaults to fill the containing panel, based on the height
- * and width of the layout. If the layout has no height and width specified, it
- * will extend to fill the enclosing panel.
- *
- * @type number
- * @name pv.Layout.Cluster.prototype.outerRadius
- */
-
-/**
- * Defaults for cluster layouts. The default group parameter is 0 and the
- * default orientation is "top".
- *
- * @type pv.Layout.Cluster
- */
-pv.Layout.Cluster.prototype.defaults = new pv.Layout.Cluster()
-    .extend(pv.Layout.Hierarchy.prototype.defaults)
-    .group(0)
-    .orient("top");
-
-/** @private */
-pv.Layout.Cluster.prototype.buildImplied = function(s) {
-  if (pv.Layout.Hierarchy.prototype.buildImplied.call(this, s)) return;
-
-  var root = s.nodes[0],
-      group = s.group,
-      breadth,
-      depth,
-      leafCount = 0,
-      leafIndex = .5 - group / 2;
-
-  /* Count the leaf nodes and compute the depth of descendants. */
-  var p = undefined;
-  root.visitAfter(function(n) {
-      if (n.firstChild) {
-        n.depth = 1 + pv.max(n.childNodes, function(n) { return n.depth; });
-      } else {
-        if (group && (p != n.parentNode)) {
-          p = n.parentNode;
-          leafCount += group;
-        }
-        leafCount++;
-        n.depth = 0;
-      }
-    });
-  breadth = 1 / leafCount;
-  depth = 1 / root.depth;
-
-  /* Compute the unit breadth and depth of each node. */
-  var p = undefined;
-  root.visitAfter(function(n) {
-      if (n.firstChild) {
-        n.breadth = pv.mean(n.childNodes, function(n) { return n.breadth; });
-      } else {
-        if (group && (p != n.parentNode)) {
-          p = n.parentNode;
-          leafIndex += group;
-        }
-        n.breadth = breadth * leafIndex++;
-      }
-      n.depth = 1 - n.depth * depth;
-    });
-
-  /* Compute breadth and depth ranges for space-filling layouts. */
-  root.visitAfter(function(n) {
-      n.minBreadth = n.firstChild
-          ? n.firstChild.minBreadth
-          : (n.breadth - breadth / 2);
-      n.maxBreadth = n.firstChild
-          ? n.lastChild.maxBreadth
-          : (n.breadth + breadth / 2);
-    });
-  root.visitBefore(function(n) {
-      n.minDepth = n.parentNode
-          ? n.parentNode.maxDepth
-          : 0;
-      n.maxDepth = n.parentNode
-          ? (n.depth + root.depth)
-          : (n.minDepth + 2 * root.depth);
-    });
-  root.minDepth = -depth;
-
-  pv.Layout.Hierarchy.NodeLink.buildImplied.call(this, s);
-};
-
-/**
- * Constructs a new, empty space-filling cluster layout. Layouts are not
- * typically constructed directly; instead, they are added to an existing panel
- * via {@link pv.Mark#add}.
- *
- * @class A variant of cluster layout that is space-filling. The meaning of the
- * exported mark prototypes changes slightly in the space-filling
- * implementation:<ul>
- *
- * <li><tt>node</tt> - for rendering nodes; typically a {@link pv.Bar} for
- * non-radial orientations, and a {@link pv.Wedge} for radial orientations.
- *
- * <p><li><tt>link</tt> - unsupported; undefined. Links are encoded implicitly
- * in the arrangement of the space-filling nodes.
- *
- * <p><li><tt>label</tt> - for rendering node labels; typically a
- * {@link pv.Label}.
- *
- * </ul>For more details on how to use this layout, see
- * {@link pv.Layout.Cluster}.
- *
- * @extends pv.Layout.Cluster
- */
-pv.Layout.Cluster.Fill = function() {
-  pv.Layout.Cluster.call(this);
-  pv.Layout.Hierarchy.Fill.constructor.call(this);
-};
-
-pv.Layout.Cluster.Fill.prototype = pv.extend(pv.Layout.Cluster);
-
-/** @private */
-pv.Layout.Cluster.Fill.prototype.buildImplied = function(s) {
-  if (pv.Layout.Cluster.prototype.buildImplied.call(this, s)) return;
-  pv.Layout.Hierarchy.Fill.buildImplied.call(this, s);
-};

data/vendor/protovis/src/layout/Force.js

@@ -1,309 +0,0 @@
-/**
- * Constructs a new, empty force-directed layout. Layouts are not typically
- * constructed directly; instead, they are added to an existing panel via
- * {@link pv.Mark#add}.
- *
- * @class Implements force-directed network layout as a node-link diagram. This
- * layout uses the Fruchterman-Reingold algorithm, which applies an attractive
- * spring force between neighboring nodes, and a repulsive electrical charge
- * force between all nodes. An additional drag force improves stability of the
- * simulation. See {@link pv.Force.spring}, {@link pv.Force.drag} and {@link
- * pv.Force.charge} for more details; note that the n-body charge force is
- * approximated using the Barnes-Hut algorithm.
- *
- * <p>This layout is implemented on top of {@link pv.Simulation}, which can be
- * used directly for more control over simulation parameters. The simulation
- * uses Position Verlet integration, which does not compute velocities
- * explicitly, but allows for easy geometric constraints, such as bounding the
- * nodes within the layout panel. Many of the configuration properties supported
- * by this layout are simply passed through to the underlying forces and
- * constraints of the simulation.
- *
- * <p>Force layouts are typically interactive. The gradual movement of the nodes
- * as they stabilize to a local stress minimum can help reveal the structure of
- * the network, as can {@link pv.Behavior.drag}, which allows the user to pick
- * up nodes and reposition them while the physics simulation continues. This
- * layout can also be used with pan &amp; zoom behaviors for interaction.
- *
- * <p>To facilitate interaction, this layout by default automatically re-renders
- * using a <tt>setInterval</tt> every 42 milliseconds. This can be disabled via
- * the <tt>iterations</tt> property, which if non-null specifies the number of
- * simulation iterations to run before the force-directed layout is finalized.
- * Be careful not to use too high an iteration count, as this can lead to an
- * annoying delay on page load.
- *
- * <p>As with other network layouts, the network data can be updated
- * dynamically, provided the property cache is reset. See
- * {@link pv.Layout.Network} for details. New nodes are initialized with random
- * positions near the center. Alternatively, positions can be specified manually
- * by setting the <tt>x</tt> and <tt>y</tt> attributes on nodes.
- *
- * @extends pv.Layout.Network
- * @see <a href="http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.13.8444&rep=rep1&type=pdf"
- * >"Graph Drawing by Force-directed Placement"</a> by T. Fruchterman &amp;
- * E. Reingold, Software--Practice &amp; Experience, November 1991.
- */
-pv.Layout.Force = function() {
-  pv.Layout.Network.call(this);
-
-  /* Force-directed graphs can be messy, so reduce the link width. */
-  this.link.lineWidth(function(d, p) { return Math.sqrt(p.linkValue) * 1.5; });
-  this.label.textAlign("center");
-};
-
-pv.Layout.Force.prototype = pv.extend(pv.Layout.Network)
-    .property("bound", Boolean)
-    .property("iterations", Number)
-    .property("dragConstant", Number)
-    .property("chargeConstant", Number)
-    .property("chargeMinDistance", Number)
-    .property("chargeMaxDistance", Number)
-    .property("chargeTheta", Number)
-    .property("springConstant", Number)
-    .property("springDamping", Number)
-    .property("springLength", Number);
-
-/**
- * The bound parameter; true if nodes should be constrained within the layout
- * panel. Bounding is disabled by default. Currently the layout does not observe
- * the radius of the nodes; strictly speaking, only the center of the node is
- * constrained to be within the panel, with an additional 6-pixel offset for
- * padding. A future enhancement could extend the bound constraint to observe
- * the node's radius, which would also support bounding for variable-size nodes.
- *
- * <p>Note that if this layout is used in conjunction with pan &amp; zoom
- * behaviors, those behaviors should have their bound parameter set to the same
- * value.
- *
- * @type boolean
- * @name pv.Layout.Force.prototype.bound
- */
-
-/**
- * The number of simulation iterations to run, or null if this layout is
- * interactive. Force-directed layouts are interactive by default, using a
- * <tt>setInterval</tt> to advance the physics simulation and re-render
- * automatically.
- *
- * @type number
- * @name pv.Layout.Force.prototype.iterations
- */
-
-/**
- * The drag constant, in the range [0,1]. A value of 0 means no drag (a
- * perfectly frictionless environment), while a value of 1 means friction
- * immediately cancels all momentum. The default value is 0.1, which provides a
- * minimum amount of drag that helps stabilize bouncy springs; lower values may
- * result in excessive bounciness, while higher values cause the simulation to
- * take longer to converge.
- *
- * @type number
- * @name pv.Layout.Force.prototype.dragConstant
- * @see pv.Force.drag#constant
- */
-
-/**
- * The charge constant, which should be a negative number. The default value is
- * -40; more negative values will result in a stronger repulsive force, which
- * may lead to faster convergence at the risk of instability. Too strong
- * repulsive charge forces can cause comparatively weak springs to be stretched
- * well beyond their rest length, emphasizing global structure over local
- * structure. A nonnegative value will break the Fruchterman-Reingold algorithm,
- * and is for entertainment purposes only.
- *
- * @type number
- * @name pv.Layout.Force.prototype.chargeConstant
- * @see pv.Force.charge#constant
- */
-
-/**
- * The minimum distance at which charge forces are applied. The default minimum
- * distance of 2 avoids applying forces that are two strong; because the physics
- * simulation is run at discrete time intervals, it is possible for two same-
- * charged particles to become very close or even a singularity! Since the
- * charge force is inversely proportional to the square of the distance, very
- * small distances can break the simulation.
- *
- * <p>In rare cases, two particles can become stuck on top of each other, as a
- * minimum distance threshold will prevent the charge force from repelling them.
- * However, this occurs very rarely because other forces and momentum typically
- * cause the particles to become separated again, at which point the repulsive
- * charge force kicks in.
- *
- * @type number
- * @name pv.Layout.Force.prototype.chargeMinDistance
- * @see pv.Force.charge#domain
- */
-
-/**
- * The maximum distance at which charge forces are applied. This improves
- * performance by ignoring weak charge forces at great distances. Note that this
- * parameter is partly redundant, as the Barnes-Hut algorithm for n-body forces
- * already improves performance for far-away particles through approximation.
- *
- * @type number
- * @name pv.Layout.Force.prototype.chargeMaxDistance
- * @see pv.Force.charge#domain
- */
-
-/**
- * The Barnes-Hut approximation factor. The Barnes-Hut approximation criterion
- * is the ratio of the size of the quadtree node to the distance from the point
- * to the node's center of mass is beneath some threshold. The default value is
- * 0.9.
- *
- * @type number
- * @name pv.Layout.Force.prototype.chargeTheta
- * @see pv.Force.charge#theta
- */
-
-/**
- * The spring constant, which should be a positive number. The default value is
- * 0.1; greater values will result in a stronger attractive force, which may
- * lead to faster convergence at the risk of instability. Too strong spring
- * forces can cause comparatively weak charge forces to be ignored, emphasizing
- * local structure over global structure. A nonpositive value will break the
- * Fruchterman-Reingold algorithm, and is for entertainment purposes only.
- *
- * <p>The spring tension is automatically normalized using the inverse square
- * root of the maximum link degree of attached nodes.
- *
- * @type number
- * @name pv.Layout.Force.prototype.springConstant
- * @see pv.Force.spring#constant
- */
-
-/**
- * The spring damping factor, in the range [0,1]. Damping functions identically
- * to drag forces, damping spring bounciness by applying a force in the opposite
- * direction of attached nodes' velocities. The default value is 0.3.
- *
- * <p>The spring damping is automatically normalized using the inverse square
- * root of the maximum link degree of attached nodes.
- *
- * @type number
- * @name pv.Layout.Force.prototype.springDamping
- * @see pv.Force.spring#damping
- */
-
-/**
- * The spring rest length. The default value is 20 pixels. Larger values may be
- * appropriate if the layout panel is larger, or if the nodes are rendered
- * larger than the default dot size of 20.
- *
- * @type number
- * @name pv.Layout.Force.prototype.springLength
- * @see pv.Force.spring#length
- */
-
-/**
- * Default properties for force-directed layouts. The default drag constant is
- * 0.1, the default charge constant is -40 (with a domain of [2, 500] and theta
- * of 0.9), and the default spring constant is 0.1 (with a damping of 0.3 and a
- * rest length of 20).
- *
- * @type pv.Layout.Force
- */
-pv.Layout.Force.prototype.defaults = new pv.Layout.Force()
-    .extend(pv.Layout.Network.prototype.defaults)
-    .dragConstant(.1)
-    .chargeConstant(-40)
-    .chargeMinDistance(2)
-    .chargeMaxDistance(500)
-    .chargeTheta(.9)
-    .springConstant(.1)
-    .springDamping(.3)
-    .springLength(20);
-
-/** @private Initialize the physics simulation. */
-pv.Layout.Force.prototype.buildImplied = function(s) {
-
-  /* Any cached interactive layouts need to be rebound for the timer. */
-  if (pv.Layout.Network.prototype.buildImplied.call(this, s)) {
-    var f = s.$force;
-    if (f) {
-      f.next = this.binds.$force;
-      this.binds.$force = f;
-    }
-    return;
-  }
-
-  var that = this,
-      nodes = s.nodes,
-      links = s.links,
-      k = s.iterations,
-      w = s.width,
-      h = s.height;
-
-  /* Initialize positions randomly near the center. */
-  for (var i = 0, n; i < nodes.length; i++) {
-    n = nodes[i];
-    if (isNaN(n.x)) n.x = w / 2 + 40 * Math.random() - 20;
-    if (isNaN(n.y)) n.y = h / 2 + 40 * Math.random() - 20;
-  }
-
-  /* Initialize the simulation. */
-  var sim = pv.simulation(nodes);
-
-  /* Drag force. */
-  sim.force(pv.Force.drag(s.dragConstant));
-
-  /* Charge (repelling) force. */
-  sim.force(pv.Force.charge(s.chargeConstant)
-      .domain(s.chargeMinDistance, s.chargeMaxDistance)
-      .theta(s.chargeTheta));
-
-  /* Spring (attracting) force. */
-  sim.force(pv.Force.spring(s.springConstant)
-      .damping(s.springDamping)
-      .length(s.springLength)
-      .links(links));
-
-  /* Position constraint (for interactive dragging). */
-  sim.constraint(pv.Constraint.position());
-
-  /* Optionally add bound constraint. TODO: better padding. */
-  if (s.bound) {
-    sim.constraint(pv.Constraint.bound().x(6, w - 6).y(6, h - 6));
-  }
-
-  /** @private Returns the speed of the given node, to determine cooling. */
-  function speed(n) {
-    return n.fix ? 1 : n.vx * n.vx + n.vy * n.vy;
-  }
-
-  /*
-   * If the iterations property is null (the default), the layout is
-   * interactive. The simulation is run until the fastest particle drops below
-   * an arbitrary minimum speed. Although the timer keeps firing, this speed
-   * calculation is fast so there is minimal CPU overhead. Note: if a particle
-   * is fixed for interactivity, treat this as a high speed and resume
-   * simulation.
-   */
-  if (k == null) {
-    sim.step(); // compute initial previous velocities
-    sim.step(); // compute initial velocities
-
-    /* Add the simulation state to the bound list. */
-    var force = s.$force = this.binds.$force = {
-      next: this.binds.$force,
-      nodes: nodes,
-      min: 1e-4 * (links.length + 1),
-      sim: sim
-    };
-
-    /* Start the timer, if not already started. */
-    if (!this.$timer) this.$timer = setInterval(function() {
-      var render = false;
-      for (var f = that.binds.$force; f; f = f.next) {
-        if (pv.max(f.nodes, speed) > f.min) {
-          f.sim.step();
-          render = true;
-        }
-      }
-      if (render) that.render();
-    }, 42);
-  } else for (var i = 0; i < k; i++) {
-    sim.step();
-  }
-};