Removes the value at the specified index. A new array will be
created containing all other elements, except the specified
element, in the order they existed in the original list.

@return the new array minus the specified element.
328790
public static int[] removeAt (int[] list, int index)
    {
        // this will NPE if the bastards passed a null list, which is how
        // we'll let them know not to do that
        int nlength = list.length-1;

        // create a new array minus the removed element
        int[] nlist = new int[nlength];
        System.arraycopy(list, 0, nlist, 0, index);
        System.arraycopy(list, index+1, nlist, index, nlength-index);

        return nlist;
    }
1137508
public void removePoint(int index) {
        int numKnots = x.length;
        if (numKnots <= 2)
            return;
        float[] nx = new float[numKnots - 1];
        float[] ny = new float[numKnots - 1];
        int j = 0;
        for (int i = 0; i < numKnots - 1; i++) {
            if (i == index)
                j++;
            nx[i] = x[j];
            ny[i] = y[j];
            j++;
        }
        x = nx;
        y = ny;
    }
231037
public Object remove(int index) {
        if (index < 0 || index >= values.size()) {
            return null;
        }
        return values.remove(index);
    }
682972
public Element put(int index, Element newValue) {

		Element oldValue = null;

        int size = list.size();

		if (index < 0) {
            if (index < -size) {
                // negative indices do not auto-prepend
                // (asopposed to positive ones that grow the list by appending undef)
                throw new EvaluationException(MessageUtils.format(
                    MSG_INVALID_NEGATIVE_LIST_INDEX, Integer.toString(index), size));
            } else {
                index += size;
            }
		}

		try {
			if ((newValue != null) && !(newValue instanceof Null)) {
				if (index >= size) {
					for (int i = 0; i < index - size; i++) {
						list.add(Undef.VALUE);
					}
					list.add(newValue);
				} else {
					oldValue = list.set(index, newValue);
					if (oldValue != null) {
						oldValue.checkValidReplacement(newValue);
					}
				}
			} else {
				try {
					oldValue = list.remove(index);
				} catch (IndexOutOfBoundsException ioobe) {
					// Ignore this error; removing non-existant element is OK.
				}
			}
		} catch (IndexOutOfBoundsException ioobe) {
			throw new EvaluationException(MessageUtils.format(
					MSG_NONEXISTANT_LIST_ELEMENT, Integer.toString(index)));
		}
		return oldValue;
	}
765091
public M remove(int index){
        M item = items.remove(index);
        applyFilter();
        return item;
    }
1105309
public static <E> E at(long index, E[] array) {
        final Iterator<E> filtered = new FilteringIterator<E>(new ArrayIterator<E>(array), new AtIndex<E>(index));
        return new FirstElement<E>().apply(filtered);
    }
1002518
public Object remove(int index) {

        //Check that the index is less than size because the getInternal
        //method is being called with index - 1 and its checks will therefore
        //not be useful in this case.
        if (index >= size()) {
            throw new IndexOutOfBoundsException("Index out of bounds: "
                                                + index + " >= " + size());
        }

        //Get the node that is previous to the node being removed
        Node previousToRemove;

        if (index == 0) {
            previousToRemove = first;
        } else {
            previousToRemove = getInternal(index - 1);
        }

        //previousToRemove.next will never be null because of the check above
        //that index < size.
        Node toRemove = previousToRemove.next;

        previousToRemove.next = toRemove.next;

        elementCount--;

        //If they removed at the last valid index, then a the last element
        //was removed, therfore update the last pointer
        if (last == toRemove) {
            last = previousToRemove;
        }

        return toRemove.data;
    }
503245
@Override
    public T remove(int index) {
        if (displacement != null) {
            return super.get(index - displacement);
        }
        return super.remove(index);
    }
26426
public T remove(boolean nullify) {
        lock.lock();
        try {
            int row_index=computeRow(hd+1);
            if(row_index < 0 || row_index >= matrix.length)
                return null;
            T[] row=matrix[row_index];
            if(row == null)
                return null;
            int index=computeIndex(hd+1);
            if(index < 0)
                return null;
            T existing_element=row[index];
            if(existing_element != null) {
                hd++;
                size=Math.max(size-1, 0); // cannot be < 0 (well that would be a bug, but let's have this 2nd line of defense !)
                if(nullify) {
                    row[index]=null;
                    if(hd - low > 0)
                        low=hd;
                }
            }
            return existing_element;
        }
        finally {
            lock.unlock();
        }
    }
119767
public E remove (int index) {
		E e = data[index]; // make copy of element to remove so it can be returned
		data[index] = data[--size]; // overwrite item to remove with last element
		data[size] = null; // null last element, so gc can do its work
		return e;
	}
618282
def remove_index(self, index):
        ''
        index_rm, single = convert_key_to_index(force_list(self.indices.keys()), index)
        if single:
            index_rm = [index_rm]

        index_new = [i for i in range(len(self.indices)) if i not in index_rm]

        if not index_new: # no index left
            self.clear(True)
            return

        names = mget_list(force_list(self.indices.keys()), index_new)
        items = [mget_list(i, index_new) for i in self.items()]
        self.clear(True)
        _MI_init(self, items, names)
853657
public static <T> T[] remove(final T[] array, final T target) {

    if (array == null) {
      return null;
    }
    int count = count(array, target);
    if (count > 0) {
      @SuppressWarnings("unchecked")
      T[] newArray = (T[]) buildArray(array.getClass().getComponentType(), array.length - count,
        null);
      int index = 0;
      for (T element : array) {
        if (JudgeUtils.notSame(element, target)) {
          newArray[index++] = element;
        }
      }
      return newArray;
    }
    return array;
  }
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;
  }
1265916
def delete(index)
      index = self.index(index) unless index.is_a?(Integer)
      stack.delete_at(index)
    end
1323107
public Object set(int index, Object element)
    {
        if ((index < m_iStartIndex) || (index >= m_iStartIndex + m_iMaxSize))
        { // Out of bounds, re-adjust bounds
            int iNewStart = index - m_iMaxSize / 2;   // index should be right in the middle
            if (iNewStart < 0)
                iNewStart = 0;
            int iStart = 0;
            int iEnd = this.size() - 1;
            int iIncrement = +1;
            if (iNewStart < m_iStartIndex)
            {   // Go backwards to avoid overlaying values
                iStart = iEnd;
                iEnd = 0;
                iIncrement = -1;
            }
            for (int i = iStart; i * iIncrement <= iEnd; i = i + iIncrement)
            {
                Object obj = super.set(i, null);                // Get and clear value
                int iShiftedIndex = i + m_iStartIndex - iNewStart;
                if ((iShiftedIndex >= 0) && (iShiftedIndex < this.size()))
                    super.set(iShiftedIndex, obj);              // Move/set it!
                else
                    this.freeObject(m_iStartIndex + i, obj);    // Notify obj
            }
            m_iStartIndex = iNewStart;
        }
        if (index >= m_iStartIndex + this.size())
        { // Need to add empty elements inbetween
            for (int i = m_iStartIndex + this.size(); i <= index; i++)
                this.add(null);     // Add a placeholder
        }
        index = index - m_iStartIndex;
        return super.set(index, element);
    }
626121
public synchronized TableModel<V> removeColumn(int index) {
        String removedColumnHeader = columns.remove(index);
        List<V> removedColumn = new ArrayList<V>();
        for(List<V> row : rows) {
            removedColumn.add(row.remove(index));
        }
        for(Listener<V> listener: listeners) {
            listener.onColumnRemoved(this, index, removedColumnHeader, removedColumn);
        }
        return this;
    }
1218343
function remove(seq, index) { var result
        result = copy(seq)
        result.splice(index, 1)
        return result
    }