<p>Set the number of rows to be displayed, or zero for all remaining rows
in the table.</p>

@param rows New number of rows

@throws IllegalArgumentException if <code>rows</code> is negative
162880
public void setRows(int rows) {

        if (rows < 0) {
            throw new IllegalArgumentException(String.valueOf(rows));
        }
        getStateHelper().put(PropertyKeys.rows, rows);

    }
970223
public void addRow(boolean[] values) {
    Node<ColumnName> prev = null;
    for(int i=0; i < values.length; ++i) {
      if (values[i]) {
        ColumnHeader<ColumnName> top = columns.get(i);
        top.size += 1;
        Node<ColumnName> bottom = top.up;
        Node<ColumnName> node = new Node<ColumnName>(null, null, bottom, 
                                                     top, top);
        bottom.down = node;
        top.up = node;
        if (prev != null) {
          Node<ColumnName> front = prev.right;
          node.left = prev;
          node.right = front;
          prev.right = node;
          front.left = node;
        } else {
          node.left = node;
          node.right = node;
        }
        prev = node;
      }
    }
  }
906700
private void justifyRows(final int from, final int to) {
		// Sometimes the DefaultTableModel is subclassed
		// instead of the AbstractTableModel by mistake.
		// Set the number of rows for the case when getRowCount
		// is overridden.
		this.dataVector.setSize(getRowCount());

		for (int i = from; i < to; i++) {
			if (this.dataVector.elementAt(i) == null) {
				this.dataVector.setElementAt(new Vector(), i);
			}
			// ((Vector)dataVector.elementAt(i)).setSize(getColumnCount());
		}
	}
292886
public void put(Set<HBeanRow> rows) {
        final List<Row> create = new ArrayList<>();
        try {
            for (HBeanRow row : rows) {
                final Put write = new Put(row.getRowKey());
                if (row.getPropertiesKeyValue() != null) {
                    write.add(row.getPropertiesKeyValue());
                }
                for (KeyValue kv : row.getPredecessors()) {
                    write.add(kv);
                }
                for (KeyValue kv : row.getReferencesKeyValue().values()) {
                    write.add(kv);
                }

                KeyValue hBean = row.getHBeanKeyValue();
                write.add(hBean);

                if (row.isSingleton()) {
                    write.add(new KeyValue(row.getRowKey(), HBeanRow.SINGLETON_COLUMN_FAMILY,
                            HBeanRow.SINGLETON_COLUMN_FAMILY, new byte[] { 1 }));
                }
                // hbase cannot have rowkeys without columns so we need
                // a dummy value to represent beans without any values
                write.add(new KeyValue(row.getRowKey(), HBeanRow.DUMMY_COLUMN_FAMILY,
                        HBeanRow.DUMMY_COLUMN_FAMILY, new byte[] { 1 }));
                create.add(write);
            }
            table.batch(create);
            table.flushCommits();
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
1163018
protected void applyRowStatistic(Statistics rowStats)
	{
		if (rowStats.exceptionCount() > 0)
		{
			stats.exception();
		}
		else if (rowStats.wrongCount() > 0)
		{
			stats.wrong();
		}
		else if (rowStats.rightCount() > 0)
		{
			stats.right();
		}
		else
		{
			stats.ignored();
		}
	}
755521
public void setTotalColorForRow(int row, Color color){
		int map = (colors[0].length-1) - row;
		colors[colors.length-1][map]=color;		
	}
899063
public void renumberViolationRowIndices(List<Integer> actualIndices) {
    violations.forEach(v -> v.renumberRowIndex(actualIndices));
  }
1183723
public void setColumn(int col, double[] values) {
    int offset = translate(0, col, numRows);
    System.arraycopy(values, 0, matrix, offset, values.length);
  }
459746
public function setNumRows($numRows,$numCols=NULL){
		for($i=sizeof($this->rows);$i<$numRows;$i++){
			$this->addRow($numCols);
		}
		return $this;
	}
1125824
public static void multRows(double[] values, DMatrixRMaj A) {
        if( values.length < A.numRows ) {
            throw new IllegalArgumentException("Not enough elements in values.");
        }

        int index = 0;
        for (int row = 0; row < A.numRows; row++) {
            double v = values[row];
            for (int col = 0; col < A.numCols; col++, index++) {
                A.data[index] *= v;
            }
        }
    }
1052205
public void addRow(final String[] data) {
		if (anyStringContainsNewLine(data)) {
			final String[][] theMatrix = Util.createMatrix(data);
			for (int i = 0; i < theMatrix.length; i++) {
				addRow(theMatrix[i]);
			}
		} else {
			final Row myRow = new Row(this, data);
			rows.add(myRow);
		}

	}
865235
public void setRow(int i, SparseVector x) {
        if (x.size() != numColumns)
            throw new IllegalArgumentException(
                    "New row must be of the same size as existing row");
        rowD[i] = x;
    }
939651
public void shuffleRowValues(ArrayList<String> rows) throws Exception {
		doubleValues.clear();
		ArrayList<String> columns = this.getColumns();
		for (String row : rows) {
			ArrayList<Integer> columnIndex = new ArrayList<Integer>();
			for (int i = 0; i < columns.size(); i++) {
				columnIndex.add(i);
			}
			Collections.shuffle(columnIndex);

			for (int i = 0; i < columns.size(); i++) {
				String column = columns.get(i);
				int randomIndex = columnIndex.get(i);
				String destinationCol = columns.get(randomIndex);

				String temp = this.getCell(row, destinationCol);
				String value = this.getCell(row, column);
				this.addCell(row, destinationCol, value);
				this.addCell(row, column, temp);
			}
		}

	}
992743
def setRows(self, rows):
        
        self._raster[0] = rows
        if self._raster[1] == 0:
            self._raster[1] = 1
895041
public void setBodyrows(java.lang.String bodyrows) {
        getStateHelper().put(PropertyKeys.bodyrows, bodyrows);
    }
389376
public final void delete(Row row) {

        for (int i = indexList.length - 1; i >= 0; i--) {
            indexList[i].delete(this, row);
        }

        remove(row.getPos());
    }
788184
public void setRow(int i, double[] array, int offset)
    {
        int n = cols;
        for (int j=0;j<n;j++)
        {
            set(i, j, array[j+offset]);
        }
    }