Removes tracks which have not been included in the inlier set recently

@return Number of dropped tracks
332846
private int dropUnusedTracks() {

		List<PointTrack> all = trackerLeft.getAllTracks(null);
		int num = 0;

		for( PointTrack t : all ) {
			LeftTrackInfo info = t.getCookie();
			if( tick - info.lastInlier > thresholdRetire ) {
				if( !trackerLeft.dropTrack(t) )
					throw new IllegalArgumentException("failed to drop unused left track");
				if( !trackerRight.dropTrack(info.right) )
					throw new IllegalArgumentException("failed to drop unused right track");
				num++;
			}
		}
//		System.out.println("  total unused dropped "+num);

		return num;
	}
146064
public function undeleteTrackAction()
    {
        if ($this->deleteTrackSnippets) {
            $params = $this->_processParameters($this->deleteTrackParameters + $this->deleteParameters);

            $this->addSnippets($this->deleteTrackSnippets, $params);
        }
    }
534695
public int getNumFaultyTrackers() {
    int count = 0;
    synchronized (this) {
      for (String trackerName : usageReports.keySet()) {
        if (isFaulty(trackerName)) {
          count++;
        }
      }
    }
    return count;
  }
580176
public String chooseRack(Set<String> excludedRacks) {
    String chosenRack = null;
    HashSet<Integer> chosenIndexes = new HashSet<Integer>();

    netlock.readLock().lock();
    try {
      int totalRacks = getNumOfRacks();
      if (totalRacks - excludedRacks.size() <= 0)
        return null; // all racks are excluded

      while (true) {
        int rackIndex;
        do {
          rackIndex = r.nextInt(totalRacks);
        } while (chosenIndexes.contains(rackIndex));
        
        chosenIndexes.add(rackIndex);
        chosenRack = racks.get(rackIndex);
        
        // if no excluded nodes are specified or the chosen node is not excluded
        // return it
        if (excludedRacks == null || (!excludedRacks.contains(chosenRack))) {
          return chosenRack;
        }
        // for sanity check if we used all indexes
        if (chosenIndexes.size() == totalRacks) {
          return null;
        }
      }
    } finally {
      netlock.readLock().unlock();
    }
  }
1296781
public Type getMissingDropped()
    {
        List<Integer> hasNoMissing = new IntList();
        for (int i = 0; i < size(); i++)
        {
            DataPoint dp = getDataPoint(i);
            boolean missing =  dp.getNumericalValues().countNaNs() > 0;
            for(int c : dp.getCategoricalValues())
                if(c < 0)
                    missing = true;
            if(!missing)
                hasNoMissing.add(i);
        }
        return getSubset(hasNoMissing);
    }
785639
public Set<DetectorFactory> getUnpositionedMembers() {
        HashSet<DetectorFactory> result = new HashSet<>(memberSet);
        result.removeAll(orderedFactoryList);
        return result;
    }
1090114
public long[] getTrackNumbers() {

        List<TrackFragmentBox> trackBoxes = this.getBoxes(TrackFragmentBox.class, false);
        long[] trackNumbers = new long[trackBoxes.size()];
        for (int trackCounter = 0; trackCounter < trackBoxes.size(); trackCounter++) {
            TrackFragmentBox trackBoxe = trackBoxes.get(trackCounter);
            trackNumbers[trackCounter] = trackBoxe.getTrackFragmentHeaderBox().getTrackId();
        }
        return trackNumbers;
    }
99195
def tracks(self):
        
        if self._tracks is None:
            self._tracks = TrackList(self.version, self.id)

        return self._tracks
354161
function(){
      Dataset.flushChanges(this);

      var deleted = this.getItems();
      var listenHandler = this.listen.item;
      var delta;

      if (deleted.length)
      {
        if (listenHandler)
          for (var i = 0; i < deleted.length; i++)
            deleted[i].removeHandler(listenHandler, this);

        this.emit_itemsChanged(delta = {
          deleted: deleted
        });

        this.members_ = {};
      }

      return delta;
    }
1097390
public Set<V> nonRemovedValues() {
        return map.values().stream().filter(entry -> !entry.removable).map(entry -> entry.val).collect(Collectors.toSet());
    }
745201
private T doRemove(int index) {
        keys[index]   = 0;
        states[index] = REMOVED;
        final Object previous = values[index];
        values[index] = missingEntries;
        --size;
        ++count;
        return (T)previous;
    }
726459
def traceCount(self):
        
        nsegs = sum([len(track) for track in self._segments])
        if nsegs == 0:
            return 0
        ntraces = 1
        for irow in range(self._autoParams.nrows()):
            ntraces = ntraces*self._autoParams.numSteps(irow)
        return ntraces
785082
def removeLastRow(self):
        """"""
        lastrow = self._segments.pop(len(self._segments)-1)
        if len(lastrow) > 0:
            raise Exception("Attempt to remove non-empty stimulus track")
70388
def delete_track(self, href=None):
        """"""

        # Argument error checking.
        assert href is not None

        raw_result = self.delete(href)

        if raw_result.status != 204:
            raise APIException(raw_result.status, raw_result.json)
629359
public List<Stanza> getCollectedStanzasAfterCancelled() {
        if (!cancelled) {
            throw new IllegalStateException("Stanza collector was not yet cancelled");
        }

        if (collectedCache == null) {
            collectedCache = new ArrayList<>(getCollectedCount());
            collectedCache.addAll(resultQueue);
        }

        return collectedCache;
    }
572188
private void cleanupIfNeccessary(JsonGetterContext excluded) {
        int cacheCount;
        while ((cacheCount = internalCache.size()) > maxContexts) {
            int sampleCount = Math.max(cacheCount - maxContexts, cleanupRemoveAtLeastItems) + 1;
            for (SamplingEntry sample: internalCache.getRandomSamples(sampleCount)) {
                if (excluded != sample.getEntryValue()) {
                    internalCache.remove(sample.getEntryKey());
                }
            }
        }
    }
119604
async def stop(self):
        
        for task in self.__tracks.values():
            if task is not None:
                task.cancel()
        self.__tracks = {}