Remove an element of the ndarray
@param idx the index of the element to be removed
@return the ndarray
341171
public INDArray removeEntry(int idx) {
        values = shiftLeft(values, idx + 1, 1, length());
        indices = shiftLeft(indices, (int) (idx * shape.length() + shape.length()), (int) shape.length(),
                        indices.length());
        return this;
    }
1082922
public int[] getIndices(long idx)
	{
		int xIndices = (int)idx%dim1;
		int yIndices = (int)(idx-xIndices)/dim1;
		int []Indices = {xIndices,yIndices};
		return Indices;
	}
170675
function RemoveItem($idx)
    {
        $result = array();
        foreach ($this->items as $currentIdx => $item)
        {
            if ($currentIdx != $idx)
                $result[] = $item;
        }
        $this->items = $result;
    }
303861
private void removeObservation( int index ) {
        final int N = y.numRows-1;
        final double d[] = y.data;

        // shift
        for( int i = index; i < N; i++ ) {
            d[i] = d[i+1];
        }
        y.numRows--;
    }
516664
void remove_child(int idx)
    {
        assert(idx >=0);
        assert(idx < get_child_count()); // this also asserts child count > 0
        assert get_child(idx) != null : "No child at index " + idx;

        _children[idx].detachFromContainer();
        int children_to_move = _child_count - idx - 1;
        if (children_to_move > 0) {
            System.arraycopy(_children, idx+1, _children, idx, children_to_move);
        }
        _child_count--;
        _children[_child_count] = null;
        structuralModificationCount++;
    }
1021545
public T removeItemAt(int index) {
        T item = get(index);
        removeItemAtIndex(index, true);
        return item;
    }
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;
    }
1001663
public boolean removeB(int index)
    {
        boundsCheck(index);
        boolean ret = array[index];
        for(int i = index; i < end-1; i++)
            array[i] = array[i+1];
        decreaseSize(1);
        return ret;
    }
1001238
public ByteArray removeTo( int index ) {
        if ( index < first() || index > last() ) {
            throw new IndexOutOfBoundsException();
        }
        // Optimisation when removing exactly one component.
        //        if (index == start() + getFirst().length()) {
        //            ByteArray component = getFirst();
        //            removeFirst();
        //            return component;
        //        }
        // Removing
        CompositeByteArray prefix = new CompositeByteArray( byteArrayFactory );
        int remaining = index - first();
        
        while ( remaining > 0 ) {
            ByteArray component = removeFirst();
            
            if ( component.last() <= remaining ) {
                // Remove entire component.
                prefix.addLast( component );
                remaining -= component.last();
            } else {
                // Remove part of component. Do this by removing entire
                // component then readding remaining bytes.
                // TODO: Consider using getIoBuffers(), as would avoid
                // performance problems for nested ComponentByteArrays.
                IoBuffer bb = component.getSingleIoBuffer();
                // get the limit of the buffer
                int originalLimit = bb.limit();
                // set the position to the beginning of the buffer
                bb.position( 0 );
                // set the limit of the buffer to what is remaining
                bb.limit( remaining );
                // create a new IoBuffer, sharing the data with 'bb'
                IoBuffer bb1 = bb.slice();
                // set the position at the end of the buffer
                bb.position( remaining );
                // gets the limit of the buffer
                bb.limit( originalLimit );
                // create a new IoBuffer, sharing teh data with 'bb'
                IoBuffer bb2 = bb.slice();
                // create a new ByteArray with 'bb1'
                ByteArray ba1 = new BufferByteArray( bb1 ) {
                    @Override
                    public void free() {
                        // Do not free.  This will get freed 
                    }
                };
                
                // add the new ByteArray to the CompositeByteArray
                prefix.addLast( ba1 );
                remaining -= ba1.last();
                
                // final for anonymous inner class
                final ByteArray componentFinal = component; 
                ByteArray ba2 = new BufferByteArray( bb2 ) {
                    @Override
                    public void free() {
                        componentFinal.free();
                    }
                };
                // add the new ByteArray to the CompositeByteArray
                addFirst( ba2 );
            }
        }
        
        // return the CompositeByteArray
        return prefix;
    }
294256
public void remove( int idx ) 
    {
        if ( idx < 0 || idx > size )
            throw new IndexOutOfBoundsException();
        int numMove = size - idx - 1;
        if ( numMove > 0 )
            System.arraycopy(items, idx + 1, items, idx, numMove);
        size--;
    }
875433
protected static Object primitiveArrayPut(Object self, int idx, Object newValue) {
        Array.set(self, normaliseIndex(idx, Array.getLength(self)), newValue);
        return newValue;
    }
1295391
public synchronized XEvent remove(int index)
			throws IndexOutOfBoundsException, IOException {
		// check overflow list and adjust indices
		XEvent removed = null;
		int smallerOverflow = 0;
		for (int i = 0; i < overflowSize; i++) {
			if (overflowIndices[i] == index) {
				removed = overflowEntries[i];
			} else if (overflowIndices[i] > index) {
				overflowIndices[i] = overflowIndices[i] - 1;
				if (removed != null) {
					// move left
					overflowIndices[i - 1] = overflowIndices[i];
					overflowEntries[i - 1] = overflowEntries[i];
				}
			} else if (overflowIndices[i] < index) {
				smallerOverflow++;
			}
		}
		if (removed != null) {
			// adjust overflow size
			overflowSize--;
			// invalidate entry in overflow set
			overflowIndices[overflowSize] = -1;
			overflowEntries[overflowSize] = null;
		} else {
			int bufferIndex = index - smallerOverflow;
			for (int hole = holeFlags.nextSetBit(0); hole >= 0
					&& hole <= bufferIndex; hole = holeFlags
					.nextSetBit(hole + 1)) {
				bufferIndex++;
			}
			removed = buffer.get(bufferIndex);
			holeFlags.set(bufferIndex, true);
		}
		size--;
		return removed;
	}
829743
@Override
    public E remove(int index) {
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
            Object[] elements = getArray();
            int len = elements.length;
            E oldValue = get(elements, index);
            int numMoved = len - index - 1;
            if (numMoved == 0)
                setArray(Arrays.copyOf(elements, len - 1));
            else {
                Object[] newElements = new Object[len - 1];
                System.arraycopy(elements, 0, newElements, 0, index);
                System.arraycopy(elements, index + 1, newElements, index,
                                 numMoved);
                setArray(newElements);
            }
            return oldValue;
        } finally {
            lock.unlock();
        }
    }
878110
function (iIndex) {
			this.setProperty("buttons", this.getProperty("buttons").splice(iIndex, 1));
			this.getFlexbox(true).removeItem(iIndex);
			return this.getFlexbox(false).removeItem(iIndex);
		}
745013
public synchronized TableModel<V> removeRow(int index) {
        List<V> removedRow = rows.remove(index);
        for(Listener<V> listener: listeners) {
            listener.onRowRemoved(this, index, removedRow);
        }
        return this;
    }
589663
public E remove(int index) {
        if (index >= mSize)
            throw new IndexOutOfBoundsException("Index: " + index + ", Size: "
                    + mSize);

        E ret = mElements.remove(index < 0 ? index + mSize : index);
        mSize--;
        return ret;
    }
1221629
public Datum<SparseArray> remove(int i) {
        Datum<SparseArray> datum = data.remove(i);

        n -= datum.x.size();
        for (SparseArray.Entry item : datum.x) {
            colSize[item.i]--;
        }
        
        return datum;
    }