// The version of get_ticks() that does the work (and the version that
 // should be overridden in subclasses).
 get_ticks_no_defaults(data_low: number, data_high: number, _cross_loc: any, desired_n_ticks: number) {
   const interval = this.get_interval(data_low, data_high, desired_n_ticks)
   const start_factor = Math.floor(data_low / interval)
   const end_factor   = Math.ceil(data_high / interval)
   let factors: number[]
   if (isStrictNaN(start_factor) || isStrictNaN(end_factor))
     factors = []
   else
     factors = range(start_factor, end_factor + 1)
   const ticks =
     factors.map((factor) => factor*interval)
            .filter((tick) => data_low <= tick && tick <= data_high)
   const num_minor_ticks = this.num_minor_ticks
   const minor_ticks = []
   if (num_minor_ticks > 0 && ticks.length > 0) {
     const minor_interval = interval / num_minor_ticks
     const minor_offsets = range(0, num_minor_ticks).map((i) => i*minor_interval)
     for (const x of minor_offsets.slice(1)) {
       minor_ticks.push(ticks[0] - x)
     }
     for (const tick of ticks) {
       for (const x of minor_offsets) {
         minor_ticks.push(tick + x)
       }
     }
   }
   return {
     major: ticks,
     minor: minor_ticks,
   }
 }

 set_initial_range(): void {
   // check for good values for ranges before setting initial range
   let good_vals = true
   const {x_ranges, y_ranges} = this.frame
   const xrs: {[key: string]: Interval} = {}
   const yrs: {[key: string]: Interval} = {}
   for (const name in x_ranges) {
     const {start, end} = x_ranges[name]
     if (start == null || end == null || isStrictNaN(start + end)) {
       good_vals = false
       break
     }
     xrs[name] = {start, end}
   }
   if (good_vals) {
     for (const name in y_ranges) {
       const {start, end} = y_ranges[name]
       if (start == null || end == null || isStrictNaN(start + end)) {
         good_vals = false
         break
       }
       yrs[name] = {start, end}
     }
   }
   if (good_vals) {
     this._initial_state_info.range = {xrs, yrs}
     logger.debug("initial ranges set")
   } else
     logger.warn('could not set initial ranges')
 }

 set_initial_range() {
   // check for good values for ranges before setting initial range
   let good_vals = true;
   const xrs = {};
   const yrs = {};
   for (const name in this.frame.x_ranges) {
     const rng = this.frame.x_ranges[name];
     if ((rng.start == null) || (rng.end == null) || isStrictNaN(rng.start + rng.end)) {
       good_vals = false;
       break;
     }
     xrs[name] = { start: rng.start, end: rng.end };
   }
   if (good_vals) {
     for (const name in this.frame.y_ranges) {
       const rng = this.frame.y_ranges[name];
       if ((rng.start == null) || (rng.end == null) || isStrictNaN(rng.start + rng.end)) {
         good_vals = false;
         break;
       }
       yrs[name] = { start: rng.start, end: rng.end };
     }
   }
   if (good_vals) {
     this._initial_state_info.range = this.initial_range_info = {xrs, yrs};
     return logger.debug("initial ranges set");
   } else {
     return logger.warn('could not set initial ranges');
   }
 }

  protected _index_data(): SpatialIndex {
    const points = []
    for (let i = 0, end = this._xs.length; i < end; i++) {
      if (this._xs[i] == null || this._xs[i].length === 0)
        continue

      const _xsi = this._xs[i]
      const xs: number[] = []
      for (let j = 0, n = _xsi.length; j < n; j++) {
        const x = _xsi[j]
        if (!isStrictNaN(x))
          xs.push(x)
      }

      const _ysi = this._ys[i]
      const ys: number[] = []
      for (let j = 0, n = _ysi.length; j < n; j++) {
        const y = _ysi[j]
        if (!isStrictNaN(y))
          ys.push(y)
      }

      const [minX, maxX] = [min(xs), max(xs)]
      const [minY, maxY] = [min(ys), max(ys)]

      points.push({minX, minY, maxX, maxY, i})
    }

    return new SpatialIndex(points)
  }

 const denanned = qs_part.filter((q) => !isStrictNaN(q))

 const nan_index = findLastIndex(qs, (q) => isStrictNaN(q))

 const nan_index = find_last_index(qs, (q) => isStrictNaN(q))