This method removes given key from counter

@param element
@return counter value
547385
public double removeKey(T element) {
        AtomicDouble v = map.remove(element);
        dirty.set(true);

        if (v != null)
            return v.get();
        else
            return 0.0;
    }
26016
public String remove(final String key) {
        if (key == null)
            return null;

        return initProps.remove(key);
    }
1359465
public Object remove (int key)
    {
        int size = _keys.length, start = key % size;
        for (int ii = 0; ii < size; ii++) {
            int idx = (ii + start) % size;
            if (_keys[idx] == key) {
                Object value = _values[idx];
                _keys[idx] = -1;
                _values[idx] = null;
                return value;
            }
        }
        return null;
    }
182781
@Override
    public T remove() {

        T retrievedElement = poll();

        if (retrievedElement == null) {
            throw new NoSuchElementException();
        }

        return retrievedElement;
    }
721787
public long indexOf(final String element) {
        return doWithJedis(new JedisCallable<Long>() {
            @Override
            public Long call(Jedis jedis) {
                return doIndexOf(jedis, element);
            }
        });
    }
978248
def discard(self, element):
        
        try:
            i = int(element)
            set.discard(self, i)
        except ValueError:
            pass
1322653
public Object remove(int index) {

        if (index >= elementCount) {
            throw new IndexOutOfBoundsException("Index out of bounds: "
                                                + index + " >= "
                                                + elementCount);
        }

        if (index < 0) {
            throw new IndexOutOfBoundsException("Index out of bounds: "
                                                + index + " < 0");
        }

        Object removedObj = elementData[index];

        for (int i = index; i < elementCount - 1; i++) {
            elementData[i] = elementData[i + 1];
        }

        elementCount--;

        if (elementCount == 0) {
            clear();
        } else {
            elementData[elementCount] = null;
        }

        return removedObj;
    }
785937
public T removeFirst() {
		if (isEmpty()) {
			return null;
		}
		T firstElement = elements[firstIndex];
		elements[firstIndex] = null;
		firstIndex = incrementIndex(firstIndex, 0);
		return firstElement;
	}
394023
public int removeKey(final K key)
    {
        @DoNotSub final int mask = values.length - 1;
        @DoNotSub int index = Hashing.hash(key, mask);

        int value;
        while (missingValue != (value = values[index]))
        {
            if (key.equals(keys[index]))
            {
                keys[index] = null;
                values[index] = missingValue;
                --size;

                compactChain(index);
                break;
            }

            index = ++index & mask;
        }

        return value;
    }
359110
public V remove (Object key)
    {
        V removed = _delegate.remove(key);
        entryRemoved(removed);
        return removed;
    }
860182
public final V remove(K key) {
        if (key == null) {
            throw new NullPointerException("key == null");
        }

        V previous;
        synchronized (this) {
            previous = map.remove(key);
            if (previous != null) {
                size -= safeSizeOf(key, previous);
            }
        }

        if (previous != null) {
            entryRemoved(false, key, previous, null);
        }

        return previous;
    }
320466
function(key, increment) {
        this._removeRemove(this.counters.remove, key);
        var op = this._getOp(this.counters.increment, key);
        if (op) {
            op.increment += increment;
        } else {
            this.counters.increment.push({key: key, increment: increment});
        }
        return this;
    }
620650
public void clear(F element) {
        Counter<S> s = maps.get(element);
        if (s != null)
            s.clear();
    }
1249349
public V remove (K removeKey) {
        V removedValue = this.store.remove(removeKey);

        if ( removedValue != null ) {
            this.notificationExecutor.fireRemoveNotification(this.listeners.iterator(), removeKey, removedValue);
        }

        return  removedValue;
    }
245560
public boolean removeElement(P element) {
		boolean changed = false;
		if (element != null) {
			GridCellElement<P> gridElement;
			for (final GridCell<P> cell : getGridCellsOn(element.getGeoLocation().toBounds2D())) {
				gridElement = cell.removeElement(element);
				if (gridElement != null) {
					if (cell.isEmpty()) {
						this.cells[cell.row()][cell.column()] = null;
						--this.cellCount;
					}
					for (final GridCell<P> otherCell : gridElement.consumeCells()) {
						assert otherCell != cell;
						otherCell.removeElement(element);
						if (otherCell.isEmpty()) {
							this.cells[otherCell.row()][otherCell.column()] = null;
							--this.cellCount;
						}
					}
					changed = true;
				}
			}
		}
		if (changed) {
			--this.elementCount;
		}
		return changed;
	}
454488
public function remove($element)
    {
        $key = array_search($element, $this->elements, true);
        if (false !== $key) {
            unset($this->elements[$key]);
            $this->elements = array_values($this->elements);
        }
        foreach ($this->subLists as $subList) {
            $subList->drop($key, true);
        }
        return $this;
    }
1081541
public GridCellElement<P> removeElement(P element) {
		final GridCellElement<P> elt = remove(element);
		if (elt != null) {
			if (elt.removeCellLink(this)) {
				--this.referenceElementCount;
			}
		}
		return elt;
	}