Subtracts all k-mers in sequence.
976019
def unconsume(self, seq):
        ''''''
        for kmer in iter_kmers(seq, self.k, canonical=self.canonical):
            self._decr(kmer)
589498
def subtract(self, number1, number2):
        """"""
        return self._format_result(int(number1) - int(number2))
1045573
def average(sequence, key):
    """"""
    return sum(map(key, sequence)) / float(len(sequence))
754450
def subtract_by_key(dict_a, dict_b):
    
    difference_dict = {}
    for key in dict_a:
        if key not in dict_b:
            difference_dict[key] = dict_a[key]

    return difference_dict
470691
public Matrix subtract(double c)
    {
        Matrix toReturn = getThisSideMatrix(null);
        toReturn.mutableSubtract(c);
        return toReturn;
    }
1303497
public static String subtractSeq(final String first, final String second) {
    return subtractSeq(first, second, DELIMITER);
  }
1243504
def LastOf(*subcons):
    
    name = "seq"
    if isinstance(subcons[0], six.string_types):
        name = subcons[0]
        subcons = subcons[1:]
    return IndexingAdapter(Sequence(name, *subcons), -1)
331920
function subtractModules(modulesA, modulesB) {
    const subtracted = [];
    for (const module of modulesA) {
      if (!modulesB.includes(module)) {
        subtracted.push(module);
      }
    }
    return subtracted;
  }
1148682
public void subtract(R1 relationships) {
        if (null == base) {
            throw new AssertionError("");
        }
        for (int i = 0; i < base.length; i++) {
            if (null == base[i]) {
                continue;
            }
            final IConceptSet set = data[i] = new SparseConceptHashSet();

            set.addAll(base[i]);
            if (null != relationships.data[i]) {
                set.removeAll(relationships.data[i]);
            }
        }
    }
387465
def subtract(self, route):
        
        for address in self.raw_maps.pop(route, NullHardwareMap()).iterkeys():
            self.pop(address, NullHardwareNode())
20716
function arraySubtraction(arrA, arrB) {
	arrA = arrA.slice();
	for (let i = 0; i < arrB.length; ++i) {
		arrA = arrA.filter(function (value) {
			return value !== arrB[i];
		});
	}
	return arrA;
}
1280143
public Matrix subtract(Matrix B)
    {
        Matrix toReturn = getThisSideMatrix(B);
        toReturn.mutableSubtract(1.0, B);
        return toReturn;
    }
691820
public void sequence(FA seq) {
        int idx;
        int relocation;

        relocation = append(seq);

        if (seq.start != -1) {
            for (idx = ends.first(); idx != -1; idx = ends.next(idx)) {
                states[idx].add(relocation + seq.start, null);
            }
        }

        ends.clear();
        for (idx = seq.ends.first(); idx != -1; idx = seq.ends.next(idx)) {
            ends.add(idx + relocation);
        }
    }
875275
def subtract(self,range2):
    
    outranges = []
    if self.chr != range2.chr:
      outranges.append(self.copy())
      return outranges
    if not self.overlaps(range2):
      outranges.append(self.copy())
      return outranges
    if range2.start <= self.start and range2.end >= self.end:
      return outranges #delete all
    if range2.start > self.start: #left side
      nrng = type(self)(self.chr,self.start+self._start_offset,range2.start-1,self.payload,self.dir)
      outranges.append(nrng)
    if range2.end < self.end: #right side
      #ugly addon to make it work for either 0 or 1 index start
      nrng = type(self)(self.chr,range2.end+1+self._start_offset,self.end,self.payload,self.dir)
      outranges.append(nrng)
    return outranges
116631
public double subtract(int[] indices, double val) {
        checkIndices(indices);
        int c = getConfigIdx(indices);
        return values.set(c, s.minus(values.get(c), val));
    }
95471
def kth_smallest(self, root, k):
        
        count = []
        self.helper(root, count)
        return count[k-1]
144793
def subtract(self, jobShape):
        
        self.shape = Shape(self.shape.wallTime,
                           self.shape.memory - jobShape.memory,
                           self.shape.cores - jobShape.cores,
                           self.shape.disk - jobShape.disk,
                           self.shape.preemptable)