Remove the element from a leaf node at the given index.
 @param index [Integer] The index of the entry to be removed
 @return [Object] The removed value
559086
def remove_element(index)
      # Delete the key at the specified index.
      unless (key = @keys.delete_at(index))
        PEROBS.log.fatal "Could not remove element #{index} from BigTreeNode " +
          "@#{@_id}"
      end
      update_branch_key(key) if index == 0

      # Delete the corresponding value.
      removed_value = @values.delete_at(index)
      if @keys.length < min_keys
        if @prev_sibling && @prev_sibling.parent == @parent
          borrow_from_previous_sibling(@prev_sibling) ||
            @prev_sibling.merge_with_leaf_node(myself)
        elsif @next_sibling && @next_sibling.parent == @parent
          borrow_from_next_sibling(@next_sibling) ||
            merge_with_leaf_node(@next_sibling)
        elsif @parent
          PEROBS.log.fatal "Cannot not find adjecent leaf siblings"
        end
      end

      # The merge has potentially invalidated this node. After this method has
      # been called this copy of the node should no longer be used.
      removed_value
    end
1330884
def remove(self, index):
        
        data = self.data
        index = self._split(index)
        for j, c in enumerate(index):
            i = int(c) - 1
            if j + 1 == len(index):
                try:
                    del data[i]
                except IndexError:
                    raise NoItemError('.'.join(index))
            else:
                data = data[i][4]
240200
public boolean remove(int index) {

        Widget w = getWidget(index);
        if (w != null) {
            return remove(getWidget(index));
        }
        return false;
    }
353986
@Override
  public Float remove(int index) {
    rangeCheck(index);
    float value = elements[index];
    for (int i = index + 1; i < size; i++) {
      elements[i - 1] = elements[i];
    }
    size -= 1;
    return value;
  }
1027169
def remove_indices(self, indices):
        
        new_list = []
        for index, element in enumerate(self):
            if index not in indices:
                new_list.append(element)
        return EList(new_list)
1237480
def delete_at(index)
      node = self
      deleted_value = nil

      while node do
        if node.is_leaf?
          deleted_value = node.values.delete_at(index)
          if node.parent
            node.parent.adjust_offsets(node, -1)
            if node.size < min_size
              node.parent.consolidate_child_nodes(node)
            end
          end

          return deleted_value
        else
          # Descend into the right child node to add the value to.
          cidx = (node.offsets.bsearch_index { |o| o > index } ||
                  node.offsets.length) - 1
          if (index -= node.offsets[cidx]) < 0
            node.fatal "Index (#{index}) became negative"
          end
          node = node.children[cidx]
        end
      end

      PEROBS.log.fatal "Could not find proper node to delete from while " +
        "looking for index #{index}"
    end
552567
def delete index
      current = @first
      index.times do
        current = current.next
      end
      current.previous.next = current.next
      current.next.previous = current.previous
    end
224489
public function remove($index) {
        $e = $this->elements[$index];
        unset($this->elements[$index]);
        $this->clean();
        $this->fire(new ListDeleteEvent($e, $index));
        return $e;
    }
1256343
def removeTab(self, index):
        
        curr_index = self.currentIndex()
        items = list(self.items())

        item = items[index]
        item.close()
        if index <= curr_index:
            self._currentIndex -= 1
1334084
@Override
    public T remove(int index) {
        /* Cache the value at the indicated position; this also does the bounds
         * check.
         */
        T result = get(index);

        /* Use a naive shuffle-down algorithm to reposition elements after
         * the removed one.
         */
        for (int i = index + 1; i < size(); ++i)
            set(i - 1, get(i));

        /* Clobber the last element to play nicely with the garbage collector. */
        set(size() - 1, null);

        /* Decrement our size. */
        --mSize;

        /* If we are now at 1/8 total capacity, shrink the structure. */
        if (size() * 8 <= mArrays.length * mArrays.length)
            shrink();
            /* Otherwise, if the size is now an even multiple of the array size,
             * we can drop the very last array.  This is the array whose offset
             * is one after the end of the elements.
             */
        else if (size() % mArrays.length == 0)
            mArrays[computeOffset(size())] = null;

        return result;
    }
503245
@Override
    public T remove(int index) {
        if (displacement != null) {
            return super.get(index - displacement);
        }
        return super.remove(index);
    }
842067
public Object remove(int index) {
        return index >= 0 && index < this.length()
            ? this.myArrayList.remove(index)
            : null;
    }
928198
function(index)
  {
    var key = this.keys[ index ];
    var lastValue = AP.pop.apply( this.values );
    var lastKey = AP.pop.apply( this.keys );

    if ( index < this.values.length )
    {
      this.values[ index ] = lastValue;
      this.keys[ index ] = lastKey;
      this.indices[ lastKey ] = index;
    }

    delete this.indices[ key ];

    return this;
  }
247152
def remove(self, child):
        
        try:
            if self.element == child.traversal_parent:
                self._remove_from_traversal_index(child)
            else:
                self._remove_from_index(child)
                self.list.remove(child)
        except:
            raise
637631
private void remove(int index) {
        int lastIndex = --size;
        Reference<E> removed = storage.array[index];
        Reference<E> lastElem = storage.array[lastIndex];
        storage.array[index] = lastElem;
        lastElem.index = index;
        removed.index = -1;
        storage.array[lastIndex] = null;
    }
32099
def remove(key)
      node = self

      while node do
        # Find index of the entry that best fits the key.
        i = node.search_key_index(key)
        if node.is_leaf
          # This is a leaf node. Check if there is an exact match for the
          # given key and return the corresponding value or nil.
          if node.keys[i] == key
            return node.remove_element(i)
          else
            return nil
          end
        end

        # Descend into the right child node to continue the search.
        node = node.children[i]
      end

      PEROBS.log.fatal 'Could not find proper node to remove from'
    end
1276820
function removeAt(items, index) {
  var copy = items.slice();
  copy.splice(index, 1);
  return copy;
}