From 91d04c64771832a0b8815ffbe1f0f9920320d94d Mon Sep 17 00:00:00 2001
From: Pamela Dragosh <pdragosh@research.att.com>
Date: Tue, 14 Feb 2017 19:41:00 -0500
Subject: Initial OpenECOMP policy/engine commit

Change-Id: I7dbff37733b661643dd4d1caefa3d7dccc361b6e
Signed-off-by: Pamela Dragosh <pdragosh@research.att.com>
---
 .../webapp/static/fusion/raptor/d3/js/d3.layout.js | 908 +++++++++++++++++++++
 1 file changed, 908 insertions(+)
 create mode 100644 ecomp-sdk-app/src/main/webapp/static/fusion/raptor/d3/js/d3.layout.js

(limited to 'ecomp-sdk-app/src/main/webapp/static/fusion/raptor/d3/js/d3.layout.js')

diff --git a/ecomp-sdk-app/src/main/webapp/static/fusion/raptor/d3/js/d3.layout.js b/ecomp-sdk-app/src/main/webapp/static/fusion/raptor/d3/js/d3.layout.js
new file mode 100644
index 000000000..abc5ebefe
--- /dev/null
+++ b/ecomp-sdk-app/src/main/webapp/static/fusion/raptor/d3/js/d3.layout.js
@@ -0,0 +1,908 @@
+(function(){d3.layout = {};
+d3.layout.chord = function() {
+  var chord = {},
+      chords,
+      groups,
+      matrix,
+      n,
+      padding = 0,
+      sortGroups,
+      sortSubgroups,
+      sortChords;
+
+  function relayout() {
+    var subgroups = {},
+        groupSums = [],
+        groupIndex = d3.range(n),
+        subgroupIndex = [],
+        k,
+        x,
+        x0,
+        i,
+        j;
+
+    chords = [];
+    groups = [];
+
+    // Compute the sum.
+    k = 0, i = -1; while (++i < n) {
+      x = 0, j = -1; while (++j < n) {
+        x += matrix[i][j];
+      }
+      groupSums.push(x);
+      subgroupIndex.push(d3.range(n));
+      k += x;
+    }
+
+    // Sort groups…
+    if (sortGroups) {
+      groupIndex.sort(function(a, b) {
+        return sortGroups(groupSums[a], groupSums[b]);
+      });
+    }
+
+    // Sort subgroups…
+    if (sortSubgroups) {
+      subgroupIndex.forEach(function(d, i) {
+        d.sort(function(a, b) {
+          return sortSubgroups(matrix[i][a], matrix[i][b]);
+        });
+      });
+    }
+
+    // Convert the sum to scaling factor for [0, 2pi].
+    // TODO Allow start and end angle to be specified.
+    // TODO Allow padding to be specified as percentage?
+    k = (2 * Math.PI - padding * n) / k;
+
+    // Compute the start and end angle for each group and subgroup.
+    x = 0, i = -1; while (++i < n) {
+      x0 = x, j = -1; while (++j < n) {
+        var di = groupIndex[i],
+            dj = subgroupIndex[i][j],
+            v = matrix[di][dj];
+        subgroups[di + "-" + dj] = {
+          index: di,
+          subindex: dj,
+          startAngle: x,
+          endAngle: x += v * k,
+          value: v
+        };
+      }
+      groups.push({
+        index: di,
+        startAngle: x0,
+        endAngle: x,
+        value: (x - x0) / k
+      });
+      x += padding;
+    }
+
+    // Generate chords for each (non-empty) subgroup-subgroup link.
+    i = -1; while (++i < n) {
+      j = i - 1; while (++j < n) {
+        var source = subgroups[i + "-" + j],
+            target = subgroups[j + "-" + i];
+        if (source.value || target.value) {
+          chords.push({
+            source: source,
+            target: target
+          })
+        }
+      }
+    }
+
+    if (sortChords) resort();
+  }
+
+  function resort() {
+    chords.sort(function(a, b) {
+      a = Math.min(a.source.value, a.target.value);
+      b = Math.min(b.source.value, b.target.value);
+      return sortChords(a, b);
+    });
+  }
+
+  chord.matrix = function(x) {
+    if (!arguments.length) return matrix;
+    n = (matrix = x) && matrix.length;
+    chords = groups = null;
+    return chord;
+  };
+
+  chord.padding = function(x) {
+    if (!arguments.length) return padding;
+    padding = x;
+    chords = groups = null;
+    return chord;
+  };
+
+  chord.sortGroups = function(x) {
+    if (!arguments.length) return sortGroups;
+    sortGroups = x;
+    chords = groups = null;
+    return chord;
+  };
+
+  chord.sortSubgroups = function(x) {
+    if (!arguments.length) return sortSubgroups;
+    sortSubgroups = x;
+    chords = null;
+    return chord;
+  };
+
+  chord.sortChords = function(x) {
+    if (!arguments.length) return sortChords;
+    sortChords = x;
+    if (chords) resort();
+    return chord;
+  };
+
+  chord.chords = function() {
+    if (!chords) relayout();
+    return chords;
+  };
+
+  chord.groups = function() {
+    if (!groups) relayout();
+    return groups;
+  };
+
+  return chord;
+};
+// A rudimentary force layout using Gauss-Seidel.
+d3.layout.force = function() {
+  var force = {},
+      event = d3.dispatch("tick"),
+      size = [1, 1],
+      alpha = .5,
+      distance = 30,
+      interval,
+      nodes,
+      links,
+      distances;
+
+  function tick() {
+    var n = distances.length,
+        i, // current index
+        o, // current link
+        s, // current source
+        t, // current target
+        l, // current distance
+        x, // x-distance
+        y; // y-distance
+
+    // gauss-seidel relaxation
+    for (i = 0; i < n; ++i) {
+      o = distances[i];
+      s = o.source;
+      t = o.target;
+      x = t.x - s.x;
+      y = t.y - s.y;
+      if (l = Math.sqrt(x * x + y * y)) {
+        l = alpha / (o.distance * o.distance) * (l - distance * o.distance) / l;
+        x *= l;
+        y *= l;
+        if (!t.fixed) {
+          t.x -= x;
+          t.y -= y;
+        }
+        if (!s.fixed) {
+          s.x += x;
+          s.y += y;
+        }
+      }
+    }
+
+    event.tick.dispatch({type: "tick"});
+
+    // simulated annealing, basically
+    return (alpha *= .99) < .005;
+  }
+
+  force.on = function(type, listener) {
+    event[type].add(listener);
+    return force;
+  };
+
+  force.nodes = function(x) {
+    if (!arguments.length) return nodes;
+    nodes = x;
+    return force;
+  };
+
+  force.links = function(x) {
+    if (!arguments.length) return links;
+    links = x;
+    return force;
+  };
+
+  force.size = function(x) {
+    if (!arguments.length) return size;
+    size = x;
+    return force;
+  };
+
+  force.distance = function(d) {
+    if (!arguments.length) return distance;
+    distance = d;
+    return force;
+  };
+
+  force.start = function() {
+    var i,
+        j,
+        k,
+        n = nodes.length,
+        m = links.length,
+        w = size[0],
+        h = size[1],
+        o;
+
+    var paths = [];
+    for (i = 0; i < n; ++i) {
+      o = nodes[i];
+      o.x = o.x || Math.random() * w;
+      o.y = o.y || Math.random() * h;
+      o.fixed = 0;
+      paths[i] = [];
+      for (j = 0; j < n; ++j) {
+        paths[i][j] = Infinity;
+      }
+      paths[i][i] = 0;
+    }
+
+    for (i = 0; i < m; ++i) {
+      o = links[i];
+      paths[o.source][o.target] = 1;
+      paths[o.target][o.source] = 1;
+      o.source = nodes[o.source];
+      o.target = nodes[o.target];
+    }
+
+    // Floyd-Warshall
+    for (k = 0; k < n; ++k) {
+      for (i = 0; i < n; ++i) {
+        for (j = 0; j < n; ++j) {
+          paths[i][j] = Math.min(paths[i][j], paths[i][k] + paths[k][j]);
+        }
+      }
+    }
+
+    distances = [];
+    for (i = 0; i < n; ++i) {
+      for (j = i + 1; j < n; ++j) {
+        distances.push({
+          source: nodes[i],
+          target: nodes[j],
+          distance: paths[i][j] * paths[i][j]
+        });
+      }
+    }
+
+    distances.sort(function(a, b) {
+      return a.distance - b.distance;
+    });
+
+    d3.timer(tick);
+    return force;
+  };
+
+  force.resume = function() {
+    alpha = .1;
+    d3.timer(tick);
+    return force;
+  };
+
+  force.stop = function() {
+    alpha = 0;
+    return force;
+  };
+
+  // use `node.call(force.drag)` to make nodes draggable
+  force.drag = function() {
+    var node, element;
+
+    this
+      .on("mouseover", function(d) { d.fixed = true; })
+      .on("mouseout", function(d) { if (d != node) d.fixed = false; })
+      .on("mousedown", mousedown);
+
+    d3.select(window)
+      .on("mousemove", mousemove)
+      .on("mouseup", mouseup);
+
+    function mousedown(d) {
+      (node = d).fixed = true;
+      element = this;
+      d3.event.preventDefault();
+    }
+
+    function mousemove() {
+      if (!node) return;
+      var m = d3.svg.mouse(element);
+      node.x = m[0];
+      node.y = m[1];
+      force.resume(); // restart annealing
+    }
+
+    function mouseup() {
+      if (!node) return;
+      mousemove();
+      node.fixed = false;
+      node = element = null;
+    }
+
+    return force;
+  };
+
+  return force;
+};
+d3.layout.partition = function() {
+  var hierarchy = d3.layout.hierarchy(),
+      size = [1, 1]; // width, height
+
+  function position(node, x, dx, dy) {
+    var children = node.children;
+    node.x = x;
+    node.y = node.depth * dy;
+    node.dx = dx;
+    node.dy = dy;
+    if (children) {
+      var i = -1,
+          n = children.length,
+          c,
+          d;
+      dx /= node.value;
+      while (++i < n) {
+        position(c = children[i], x, d = c.value * dx, dy);
+        x += d;
+      }
+    }
+  }
+
+  function depth(node) {
+    var children = node.children,
+        d = 0;
+    if (children) {
+      var i = -1,
+          n = children.length;
+      while (++i < n) d = Math.max(d, depth(children[i]));
+    }
+    return 1 + d;
+  }
+
+  function partition(d, i) {
+    var nodes = hierarchy.call(this, d, i);
+    position(nodes[0], 0, size[0], size[1] / depth(nodes[0]));
+    return nodes;
+  }
+
+  partition.sort = d3.rebind(partition, hierarchy.sort);
+  partition.children = d3.rebind(partition, hierarchy.children);
+  partition.value = d3.rebind(partition, hierarchy.value);
+
+  partition.size = function(x) {
+    if (!arguments.length) return size;
+    size = x;
+    return partition;
+  };
+
+  return partition;
+};
+d3.layout.pie = function() {
+  var value = Number,
+      sort = null,
+      startAngle = 0,
+      endAngle = 2 * Math.PI;
+
+  function pie(data, i) {
+
+    // Compute the start angle.
+    var a = +(typeof startAngle == "function"
+        ? startAngle.apply(this, arguments)
+        : startAngle);
+
+    // Compute the angular range (end - start).
+    var k = (typeof endAngle == "function"
+        ? endAngle.apply(this, arguments)
+        : endAngle) - startAngle;
+
+    // Optionally sort the data.
+    var index = d3.range(data.length);
+    if (sort != null) index.sort(function(i, j) {
+      return sort(data[i], data[j]);
+    });
+
+    // Compute the numeric values for each data element.
+    var values = data.map(value);
+
+    // Convert k into a scale factor from value to angle, using the sum.
+    k /= values.reduce(function(p, d) { return p + d; }, 0);
+
+    // Compute the arcs!
+    var arcs = index.map(function(i) {
+      return {
+        value: d = values[i],
+        startAngle: a,
+        endAngle: a += d * k
+      };
+    });
+
+    // Return the arcs in the original data's order.
+    return data.map(function(d, i) {
+      return arcs[index[i]];
+    });
+  }
+
+  /**
+   * Specifies the value function *x*, which returns a nonnegative numeric value
+   * for each datum. The default value function is `Number`. The value function
+   * is passed two arguments: the current datum and the current index.
+   */
+  pie.value = function(x) {
+    if (!arguments.length) return value;
+    value = x;
+    return pie;
+  };
+
+  /**
+   * Specifies a sort comparison operator *x*. The comparator is passed two data
+   * elements from the data array, a and b; it returns a negative value if a is
+   * less than b, a positive value if a is greater than b, and zero if a equals
+   * b.
+   */
+  pie.sort = function(x) {
+    if (!arguments.length) return sort;
+    sort = x;
+    return pie;
+  };
+
+  /**
+   * Specifies the overall start angle of the pie chart. Defaults to 0. The
+   * start angle can be specified either as a constant or as a function; in the
+   * case of a function, it is evaluated once per array (as opposed to per
+   * element).
+   */
+  pie.startAngle = function(x) {
+    if (!arguments.length) return startAngle;
+    startAngle = x;
+    return pie;
+  };
+
+  /**
+   * Specifies the overall end angle of the pie chart. Defaults to 2π. The
+   * end angle can be specified either as a constant or as a function; in the
+   * case of a function, it is evaluated once per array (as opposed to per
+   * element).
+   */
+  pie.endAngle = function(x) {
+    if (!arguments.length) return endAngle;
+    endAngle = x;
+    return pie;
+  };
+
+  return pie;
+};
+// data is two-dimensional array of x,y; we populate y0
+// TODO perhaps make the `x`, `y` and `y0` structure customizable
+d3.layout.stack = function() {
+  var order = "default",
+      offset = "zero";
+
+  function stack(data) {
+    var n = data.length,
+        m = data[0].length,
+        i,
+        j,
+        y0;
+
+    // compute the order of series
+    var index = d3_layout_stackOrders[order](data);
+
+    // set y0 on the baseline
+    d3_layout_stackOffsets[offset](data, index);
+
+    // propagate offset to other series
+    for (j = 0; j < m; ++j) {
+      for (i = 1, y0 = data[index[0]][j].y0; i < n; ++i) {
+        data[index[i]][j].y0 = y0 += data[index[i - 1]][j].y;
+      }
+    }
+
+    return data;
+  }
+
+  stack.order = function(x) {
+    if (!arguments.length) return order;
+    order = x;
+    return stack;
+  };
+
+  stack.offset = function(x) {
+    if (!arguments.length) return offset;
+    offset = x;
+    return stack;
+  };
+
+  return stack;
+}
+
+var d3_layout_stackOrders = {
+
+  "inside-out": function(data) {
+    var n = data.length,
+        i,
+        j,
+        max = data.map(d3_layout_stackMaxIndex),
+        sums = data.map(d3_layout_stackReduceSum),
+        index = d3.range(n).sort(function(a, b) { return max[a] - max[b]; }),
+        top = 0,
+        bottom = 0,
+        tops = [],
+        bottoms = [];
+    for (i = 0; i < n; i++) {
+      j = index[i];
+      if (top < bottom) {
+        top += sums[j];
+        tops.push(j);
+      } else {
+        bottom += sums[j];
+        bottoms.push(j);
+      }
+    }
+    return bottoms.reverse().concat(tops);
+  },
+
+  "reverse": function(data) {
+    return d3.range(data.length).reverse();
+  },
+
+  "default": function(data) {
+    return d3.range(data.length);
+  }
+
+};
+
+var d3_layout_stackOffsets = {
+
+  "silhouette": function(data, index) {
+    var n = data.length,
+        m = data[0].length,
+        sums = [],
+        max = 0,
+        i,
+        j,
+        o;
+    for (j = 0; j < m; ++j) {
+      for (i = 0, o = 0; i < n; i++) o += data[i][j].y;
+      if (o > max) max = o;
+      sums.push(o);
+    }
+    for (j = 0, i = index[0]; j < m; ++j) {
+      data[i][j].y0 = (max - sums[j]) / 2;
+    }
+  },
+
+  "wiggle": function(data, index) {
+    var n = data.length,
+        x = data[0],
+        m = x.length,
+        max = 0,
+        i,
+        j,
+        k,
+        ii,
+        ik,
+        i0 = index[0],
+        s1,
+        s2,
+        s3,
+        dx,
+        o,
+        o0;
+    data[i0][0].y0 = o = o0 = 0;
+    for (j = 1; j < m; ++j) {
+      for (i = 0, s1 = 0; i < n; ++i) s1 += data[i][j].y;
+      for (i = 0, s2 = 0, dx = x[j].x - x[j - 1].x; i < n; ++i) {
+        for (k = 0, ii = index[i], s3 = (data[ii][j].y - data[ii][j - 1].y) / (2 * dx); k < i; ++k) {
+          s3 += (data[ik = index[k]][j].y - data[ik][j - 1].y) / dx;
+        }
+        s2 += s3 * data[ii][j].y;
+      }
+      data[i0][j].y0 = o -= s1 ? s2 / s1 * dx : 0;
+      if (o < o0) o0 = o;
+    }
+    for (j = 0; j < m; ++j) data[i0][j].y0 -= o0;
+  },
+
+  "zero": function(data, index) {
+    var j = 0,
+        m = data[0].length,
+        i0 = index[0];
+    for (; j < m; ++j) data[i0][j].y0 = 0;
+  }
+
+};
+
+function d3_layout_stackReduceSum(d) {
+  return d.reduce(d3_layout_stackSum, 0);
+}
+
+function d3_layout_stackMaxIndex(array) {
+  var i = 1,
+      j = 0,
+      v = array[0].y,
+      k,
+      n = array.length;
+  for (; i < n; ++i) {
+    if ((k = array[i].y) > v) {
+      j = i;
+      v = k;
+    }
+  }
+  return j;
+}
+
+function d3_layout_stackSum(p, d) {
+  return p + d.y;
+}
+d3.layout.hierarchy = function() {
+  var sort = d3_layout_hierarchySort,
+      children = d3_layout_hierarchyChildren,
+      value = d3_layout_hierarchyValue;
+
+  // Recursively compute the node depth and value.
+  // Also converts the data representation into a standard hierarchy structure.
+  function recurse(data, depth, nodes) {
+    var datas = children.call(hierarchy, data, depth),
+        node = {depth: depth, data: data};
+    nodes.push(node);
+    if (datas) {
+      var i = -1,
+          n = datas.length,
+          c = node.children = [],
+          v = 0,
+          j = depth + 1;
+      while (++i < n) {
+        d = recurse(datas[i], j, nodes);
+        if (d.value > 0) { // ignore NaN, negative, etc.
+          c.push(d);
+          v += d.value;
+          d.parent = node;
+        }
+      }
+      if (sort) c.sort(sort);
+      node.value = v;
+    } else {
+      node.value = value.call(hierarchy, data, depth);
+    }
+    return node;
+  }
+
+  // Recursively re-evaluates the node value.
+  function revalue(node, depth) {
+    var children = node.children,
+        v = 0;
+    if (children) {
+      var i = -1,
+          n = children.length,
+          j = depth + 1;
+      while (++i < n) v += revalue(children[i], j);
+    } else {
+      v = value.call(hierarchy, node.data, depth);
+    }
+    return node.value = v;
+  }
+
+  function hierarchy(d) {
+    var nodes = [];
+    recurse(d, 0, nodes);
+    return nodes;
+  }
+
+  hierarchy.sort = function(x) {
+    if (!arguments.length) return sort;
+    sort = x;
+    return hierarchy;
+  };
+
+  hierarchy.children = function(x) {
+    if (!arguments.length) return children;
+    children = x;
+    return hierarchy;
+  };
+
+  hierarchy.value = function(x) {
+    if (!arguments.length) return value;
+    value = x;
+    return hierarchy;
+  };
+
+  // Re-evaluates the `value` property for the specified hierarchy.
+  hierarchy.revalue = function(root) {
+    revalue(root, 0);
+    return root;
+  };
+
+  return hierarchy;
+}
+
+function d3_layout_hierarchyChildren(d) {
+  return d.children;
+}
+
+function d3_layout_hierarchyValue(d) {
+  return d.value;
+}
+
+function d3_layout_hierarchySort(a, b) {
+  return b.value - a.value;
+}
+// Squarified Treemaps by Mark Bruls, Kees Huizing, and Jarke J. van Wijk
+d3.layout.treemap = function() {
+  var hierarchy = d3.layout.hierarchy(),
+      round = Math.round,
+      size = [1, 1], // width, height
+      sticky = false,
+      stickies;
+
+  // Recursively compute the node area based on value & scale.
+  function scale(node, k) {
+    var children = node.children;
+    node.area = node.value * k;
+    if (children) {
+      var i = -1,
+          n = children.length;
+      while (++i < n) scale(children[i], k);
+    }
+  }
+
+  // Recursively arranges the specified node's children into squarified rows.
+  function squarify(node) {
+    if (!node.children) return;
+    var rect = {x: node.x, y: node.y, dx: node.dx, dy: node.dy},
+        row = [],
+        children = node.children.slice(), // copy-on-write
+        child,
+        best = Infinity, // the best row score so far
+        score, // the current row score
+        u = Math.min(rect.dx, rect.dy), // initial orientation
+        n;
+    row.area = 0;
+    while ((n = children.length) > 0) {
+      row.push(child = children[n - 1]);
+      row.area += child.area;
+      if ((score = worst(row, u)) <= best) { // continue with this orientation
+        children.pop();
+        best = score;
+      } else { // abort, and try a different orientation
+        row.area -= row.pop().area;
+        position(row, u, rect, false);
+        u = Math.min(rect.dx, rect.dy);
+        row.length = row.area = 0;
+        best = Infinity;
+      }
+    }
+    if (row.length) {
+      position(row, u, rect, true);
+      row.length = row.area = 0;
+    }
+    node.children.forEach(squarify);
+  }
+
+  // Recursively resizes the specified node's children into existing rows.
+  // Preserves the existing layout!
+  function stickify(node) {
+    if (!node.children) return;
+    var rect = {x: node.x, y: node.y, dx: node.dx, dy: node.dy},
+        children = node.children.slice(), // copy-on-write
+        child,
+        row = [];
+    row.area = 0;
+    while (child = children.pop()) {
+      row.push(child);
+      row.area += child.area;
+      if (child.z != null) {
+        position(row, child.z ? rect.dx : rect.dy, rect, !children.length);
+        row.length = row.area = 0;
+      }
+    }
+    node.children.forEach(stickify);
+  }
+
+  // Computes the score for the specified row, as the worst aspect ratio.
+  function worst(row, u) {
+    var s = row.area,
+        r,
+        rmax = 0,
+        rmin = Infinity,
+        i = -1,
+        n = row.length;
+    while (++i < n) {
+      r = row[i].area;
+      if (r < rmin) rmin = r;
+      if (r > rmax) rmax = r;
+    }
+    s *= s;
+    u *= u;
+    return Math.max((u * rmax) / s, s / (u * rmin));
+  }
+
+  // Positions the specified row of nodes. Modifies `rect`.
+  function position(row, u, rect, flush) {
+    var i = -1,
+        n = row.length,
+        x = rect.x,
+        y = rect.y,
+        v = u ? round(row.area / u) : 0,
+        o;
+    if (u == rect.dx) { // horizontal subdivision
+      if (flush || v > rect.dy) v = rect.dy; // over+underflow
+      while (++i < n) {
+        o = row[i];
+        o.x = x;
+        o.y = y;
+        o.dy = v;
+        x += o.dx = round(o.area / v);
+      }
+      o.z = true;
+      o.dx += rect.x + rect.dx - x; // rounding error
+      rect.y += v;
+      rect.dy -= v;
+    } else { // vertical subdivision
+      if (flush || v > rect.dx) v = rect.dx; // over+underflow
+      while (++i < n) {
+        o = row[i];
+        o.x = x;
+        o.y = y;
+        o.dx = v;
+        y += o.dy = round(o.area / v);
+      }
+      o.z = false;
+      o.dy += rect.y + rect.dy - y; // rounding error
+      rect.x += v;
+      rect.dx -= v;
+    }
+  }
+
+  function treemap(d) {
+    var nodes = stickies || hierarchy(d),
+        root = nodes[0];
+    root.x = 0;
+    root.y = 0;
+    root.dx = size[0];
+    root.dy = size[1];
+    if (stickies) hierarchy.revalue(root);
+    scale(root, size[0] * size[1] / root.value);
+    (stickies ? stickify : squarify)(root);
+    if (sticky) stickies = nodes;
+    return nodes;
+  }
+
+  treemap.sort = d3.rebind(treemap, hierarchy.sort);
+  treemap.children = d3.rebind(treemap, hierarchy.children);
+  treemap.value = d3.rebind(treemap, hierarchy.value);
+
+  treemap.size = function(x) {
+    if (!arguments.length) return size;
+    size = x;
+    return treemap;
+  };
+
+  treemap.round = function(x) {
+    if (!arguments.length) return round != Number;
+    round = x ? Math.round : Number;
+    return treemap;
+  };
+
+  treemap.sticky = function(x) {
+    if (!arguments.length) return sticky;
+    sticky = x;
+    stickies = null;
+    return treemap;
+  };
+
+  return treemap;
+};
+})()
\ No newline at end of file
-- 
cgit 1.2.3-korg