Removes completely a list of columns from the dataset. The meta-data of
the Dataframe are updated. The method internally uses threads.

@param columnSet
162707
public void dropXColumns(Set<Object> columnSet) {
        columnSet.retainAll(data.xDataTypes.keySet()); //keep only those columns that are already known to the Meta data of the Dataframe

        if(columnSet.isEmpty()) {
            return;
        }

        //remove all the columns from the Meta data
        data.xDataTypes.keySet().removeAll(columnSet);

        streamExecutor.forEach(StreamMethods.stream(entries(), true), e -> {
            Integer rId = e.getKey();
            Record r = e.getValue();

            AssociativeArray xData = r.getX().copy();
            boolean modified = xData.keySet().removeAll(columnSet);

            if(modified) {
                Record newR = new Record(xData, r.getY(), r.getYPredicted(), r.getYPredictedProbabilities());

                //safe to call in this context. we already updated the meta when we modified the xDataTypes
                _unsafe_set(rId, newR);
            }
        });

    }
766683
public void invalidateDataSet () {
		updateCurrentItem(MathUtils.clamp(currentIndex, 0, items.size - 1));
		spinner.notifyValueChanged(true);
	}
115421
def deletecols(self, cols):
        
        if isinstance(cols, str):
        	cols = cols.split(',')
        deletenames = utils.uniqify(utils.listunion([[c] if c in 
        self.dtype.names else self.coloring[c] for c in cols]))
        return spreadsheet.deletecols(self,deletenames)
348738
public static void pruneDenseTableColumnsV2(List<RawColumn> columns) {
    ListIterator<RawColumn> iterator = columns.listIterator();
    while (iterator.hasNext()) {
      RawColumn column = iterator.next();
      if (column.kind.equals(KIND_COMPACT_VALUE) && column.name.asInternal().isEmpty()) {
        iterator.remove();
      }
    }
  }
886349
public void setColumns(List<Cell> columns)
    {
        for (Cell column : columns)
        {
            putColumn(CellUtil.cloneFamily(column), CellUtil.cloneQualifier(column), CellUtil.cloneValue(column));
        }
    }
469506
public void deleteAllRows() {
        rows.clear();
        rows.add(new Row(columns));
        curPosition.setLocation(0, 0);
        lastHeaderRow = -1;
    }
424229
public void removeFromSet (String setName, Comparable<?> key)
    {
        requestEntryRemove(setName, getSet(setName), key);
    }
1192307
def delete_dataset(dataset_id,**kwargs):
    
    try:
        d = db.DBSession.query(Dataset).filter(Dataset.id==dataset_id).one()
    except NoResultFound:
        raise HydraError("Dataset %s does not exist."%dataset_id)

    dataset_rs = db.DBSession.query(ResourceScenario).filter(ResourceScenario.dataset_id==dataset_id).all()
    if len(dataset_rs) > 0:
        raise HydraError("Cannot delete %s. Dataset is used by one or more resource scenarios."%dataset_id)

    db.DBSession.delete(d)

    db.DBSession.flush()

    #Remove ORM references to children of this dataset (metadata, collection items)
    db.DBSession.expunge_all()
320269
@Override
    public Table removeColumns(Column<?>... columns) {
        columnList.removeAll(Arrays.asList(columns));
        return this;
    }
299542
public void setDataSet(PagedDataSet dataSet) {
        /* todo: would be nice to address this side-effect outside of the setter */
        _dataSet = dataSet;
        _dataGridState.getPagerModel().setDataSetSize(_dataSet.getSize());
    }
1031193
def delete_columns(self, columns):
        
        columns = [columns] if not isinstance(columns, (list, blist)) else columns
        if not all([x in self._columns for x in columns]):
            raise ValueError('all columns must be in current columns')
        for column in columns:
            c = self._columns.index(column)
            del self._data[c]
            del self._columns[c]
        if not len(self._data):  # if all the columns have been deleted, remove index
            self.index = list()
260838
def removeContinuousSet(self, continuousSet):
        
        q = models.ContinuousSet.delete().where(
            models.ContinuousSet.id == continuousSet.getId())
        q.execute()
276548
def removeReferenceSet(self):
        
        self._openRepo()
        referenceSet = self._repo.getReferenceSetByName(
            self._args.referenceSetName)

        def func():
            self._updateRepo(self._repo.removeReferenceSet, referenceSet)
        self._confirmDelete("ReferenceSet", referenceSet.getLocalId(), func)
823861
def removecolkeyword(self, columnname, keyword):
        
        if isinstance(keyword, str):
            self._removekeyword(columnname, keyword, -1)
        else:
            self._removekeyword(columnname, '', keyword)
1098248
public static void removeColumns( DMatrixRMaj A , int col0 , int col1 )
    {
        if( col1 < col0 ) {
            throw new IllegalArgumentException("col1 must be >= col0");
        } else if( col0 >= A.numCols || col1 >= A.numCols ) {
            throw new IllegalArgumentException("Columns which are to be removed must be in bounds");
        }

        int step = col1-col0+1;
        int offset = 0;
        for (int row = 0, idx=0; row < A.numRows; row++) {
            for (int i = 0; i < col0; i++,idx++) {
                A.data[idx] = A.data[idx+offset];
            }
            offset += step;
            for (int i = col1+1; i < A.numCols; i++,idx++) {
                A.data[idx] = A.data[idx+offset];
            }
        }
        A.numCols -= step;
    }
1096797
protected static void printDataSet(DataSet dataSet) {
        final String SPACER = "| \t |";

        if (dataSet == null) System.out.println("DataSet is null");
        if (dataSet.getRowCount() == 0) System.out.println("DataSet is empty");

        List<DataColumn> dataSetColumns = dataSet.getColumns();
        int colColunt = dataSetColumns.size();
        int rowCount = dataSet.getRowCount();

        System.out.println("********************************************************************************************************************************************************");
        for (int row = 0; row < rowCount; row++) {
            System.out.print(SPACER);
            for (int col= 0; col< colColunt; col++) {
                Object value = dataSet.getValueAt(row, col);
                String colId = dataSet.getColumnByIndex(col).getId();
                System.out.print(colId + ": " +  value);
                System.out.print(SPACER);
            }
            System.out.println("");
        }
        System.out.println("********************************************************************************************************************************************************");
    }
455740
public void clear() {
		columnLookup.clear();
		rowLookup.clear();
		data = null;
		dataGrid.clear();
		doubleValues.clear();
		System.gc();
	}