How to use the binary-search-bounds.le function in binary-search-bounds

const position = ([] as number[]).concat(...indices.map(i => {
      // Which ring we are on as a value between 0 and 1
      const idx = bounds.le(cRows, i)
      const phi = idx / rows.length
      // How far around the ring we are as a value between 0 and 1
      const theta = (i - cRows[idx]) / rows[idx]
      return [phi, theta]
    }))

console.log(
      dedent`${opName}, Operations, ${ops}
      ${opName}, AverageLatency(us), ${stats.mean(lats)}
      ${opName}, LatencyVariance(us), ${stats.stdev(lats)}
      ${opName}, MinLatency(us), ${lats[0]}
      ${opName}, MaxLatency(us), ${lats[lats.length - 1]}
      ${opName}, 95thPercentileLatency(us), ${stats.percentile(lats, 0.95)}
      ${opName}, 99thPercentileLatency(us), ${stats.percentile(lats, 0.99)}
      ${opName}, 99.9thPercentileLatency(us), ${stats.percentile(lats, 0.999)}
      ${opName}, Return=OK, ${ops}`
    );

    for (let i = 0; i < numBucket; i++) {
      const hi = bounds.lt(lats, i + 1);
      const lo = bounds.le(lats, i);
      console.log(`${opName}, ${i}, ${hi - lo}`);
    }

    const lo = bounds.le(lats, numBucket);
    console.log(`${opName}, ${numBucket}, ${ops - lo}`);
  });
}

function getConnectingVerts(node, vertex) {
    if(!node) {
      return
    }
    var idx = bsearch.le(node.verts, vertex, function(a, b) {
      return a[1] - vertex[1]
    })
    if(idx < 0) {
      addEdge(node.verts[0], vertex)
    } else if(node.verts[idx][1] === vertex[1]) {
      addEdge(node.verts[idx], vertex)
    } else {
      addEdge(node.verts[idx], vertex)
      if(idx < node.verts.length - 1) {
        addEdge(node.verts[idx+1], vertex)
      }
    }
    if(vertex[0] < node.x) {
      getConnectingVerts(node.left, vertex)
    } else if(vertex[0] > node.x) {
      getConnectingVerts(node.right, vertex)

var ptr = 0

  for (var j = 0; j < numY - 1; ++j) {
    var yc0 = ys * (y[j] - loy)
    var yc1 = ys * (y[j + 1] - loy)
    for (var i = 0; i < numX - 1; ++i) {
      var xc0 = xs * (x[i] - lox)
      var xc1 = xs * (x[i + 1] - lox)

      for (var dd = 0; dd < WEIGHTS.length; dd += 2) {
        var dx = WEIGHTS[dd]
        var dy = WEIGHTS[dd + 1]
        var offset = (j + dy) * numX + (i + dx)
        var zc = z[offset]
        var colorIdx = bsearch.le(colorLevels, zc)
        var r, g, b, a
        if (colorIdx < 0) {
          r = colorValues[0]
          g = colorValues[1]
          b = colorValues[2]
          a = colorValues[3]
        } else if (colorIdx === colorCount - 1) {
          r = colorValues[4 * colorCount - 4]
          g = colorValues[4 * colorCount - 3]
          b = colorValues[4 * colorCount - 2]
          a = colorValues[4 * colorCount - 1]
        } else {
          var t = (zc - colorLevels[colorIdx]) /
            (colorLevels[colorIdx + 1] - colorLevels[colorIdx])
          var ti = 1.0 - t
          var i0 = 4 * colorIdx

function getState(trajectory, t) {
  var idx = bsearch.le(trajectory, t, testState)
  if(idx < 0) {
    return new State(trajectory[0].x.slice(), trajectory[0].v.slice(), trajectory[0].t, "create")
  }
  if(idx === trajectory.length - 1) {
    var a = trajectory[idx]
    if("destroy" === a.event) {
      return new State(trajectory[idx].x.slice(), [0,0], trajectory[0].t, "destroy")
    }
    var dt = t - a.t
    var nx = [a.x[0] + a.v[0] * dt, a.x[1] + a.v[1] * dt]
    return new State(nx, a.v.slice(), t)
  }
  var a = trajectory[idx]
  var b = trajectory[idx+1]
  var dt = (t - a.t) / (b.t - a.t)
  return new State(

function getState(trajectory, t) {
  var idx = bsearch.le(trajectory, t, testState)
  if(idx < 0) {
    return new State(trajectory[0].x.slice(), trajectory[0].v.slice(), trajectory[0].t, "create")
  }
  if(idx === trajectory.length - 1) {
    var a = trajectory[idx]
    if("destroy" === a.event) {
      return new State(trajectory[idx].x.slice(), [0,0], trajectory[0].t, "destroy")
    }
    var dt = t - a.t
    var nx = [a.x[0] + a.v[0] * dt, a.x[1] + a.v[1] * dt]
    return new State(nx, a.v.slice(), t)
  }
  var a = trajectory[idx]
  var b = trajectory[idx+1]
  var dt = (t - a.t) / (b.t - a.t)
  return new State(

function splitHulls(hulls, points, event) {
  var splitIdx = bsearch.le(hulls, event, findSplit)
  var hull = hulls[splitIdx]
  var upperIds = hull.upperIds
  var x = upperIds[upperIds.length-1]
  hull.upperIds = [x]
  hulls.splice(splitIdx+1, 0,
    new PartialHull(event.a, event.b, event.idx, [x], upperIds))
}

proto.curve = function(t) {
  var time      = this._time
  var n         = time.length
  var idx       = bsearch.le(time, t)
  var result    = this._scratch[0]
  var state     = this._state
  var velocity  = this._velocity
  var d         = this.dimension
  var bounds    = this.bounds
  if(idx < 0) {
    var ptr = d-1
    for(var i=0; i= n-1) {
    var ptr = state.length-1
    var tf = t - time[n-1]
    for(var i=0; i