Returns all items for the given row where there was no input value, sorted by rating.
@param row The row to return values for
@returns Array An array of arrays, each containing two entries. [0] is the index and [1] is the value, sorted by value.
333549
function(row)
	{
		var recommendedItems = new Array();
		var allItems = this.rankAllItems(row);
			
		var rowIndex = row; // assume row is a number
		// If we're using labels we have to look up the row index
		if(this.rowLabels)
		{
			rowIndex = findInArray(this.rowLabels, row);
		}
		
		for(var i=0; i< allItems.length; i++)
		{
			// look up the value in the input
			var colIndex = allItems[i][0];
			// see if we're using column labels or not
			if(this.colLabels) 
			{
				colIndex = findInArray(this.colLabels, allItems[i][0]);
			}
			
			var inputRating = this.input.e(rowIndex+1, colIndex+1);
			
			// if there was no rating its a recommendation so add it
			if(inputRating == 0)
			{
				recommendedItems.push(allItems[i]);
			}
		}
		
		return recommendedItems;
	}
783597
private List<MapRow> sort(List<MapRow> rows, final String attribute)
   {
      Collections.sort(rows, new Comparator<MapRow>()
      {
         @Override public int compare(MapRow o1, MapRow o2)
         {
            String value1 = o1.getString(attribute);
            String value2 = o2.getString(attribute);
            return value1.compareTo(value2);
         }
      });
      return rows;
   }
821864
protected List getAsList(Map<String, Object> row, String columnName) {
		return (List)row.get(columnName);
	}
745750
@Override
	protected String[] getRow(String[] resultRow) {
		return Arrays.copyOfRange(resultRow, 1, resultRow.length);
	}
702284
public double[] getRow(int row) {
    double[] rowArray = new double[getColumnCount()];
    for (int i = 0; i < getColumnCount(); i++) {
      rowArray[i] = get(row, i);
    }
    return rowArray;
  }
144730
BlockTree toSorted(Row row)
  {
    if (getIndex() == BLOCK_SIZE) {
      return this;
    }
    
    int keyLength = row.keyLength();
    
    _sortHead = getIndex();
    
    _keyMinSort = new byte[keyLength];
    _keyMaxSort = new byte[keyLength];
    
    int minOffset = 1;
    int maxOffset = minOffset + keyLength;
    int tupleLength = row.getTreeItemLength();
    
    byte []buffer = getBuffer();
    
    System.arraycopy(buffer, _sortHead + maxOffset,
                     _keyMaxSort, 0, 
                     keyLength);
    
    System.arraycopy(buffer, BLOCK_SIZE - tupleLength + minOffset,
                     _keyMinSort, 0, 
                     keyLength);
    
    return this;
  }
102072
public static List<Integer> rowIndexStringToList(final String row) {
		if (row == null) {
			return null;
		}

		List<Integer> rowIndex = new ArrayList<>();

		try {

			// Convert StringId to array
			String[] rowIdString = row.split(INDEX_DELIMITER);
			for (int i = 0; i < rowIdString.length; i++) {
				rowIndex.add(Integer.parseInt(rowIdString[i]));
			}
		} catch (NumberFormatException e) {
			LOG.warn("Invalid row id: " + row);
		}

		return rowIndex;
	}
1363428
def last(self, rows: List[Row]) -> List[Row]:
        
        if not rows:
            logger.warning("Trying to get last row from an empty list")
            return []
        return [rows[-1]]
542439
public JKTableRecord getRecord(final int row) {
		if (row >= getRowCount()) {
			throw new IllegalStateException("Row : " + row + " is out of index");
		}
		return this.records.get(row);
	}
1087845
private int getIndex(int row, int column) {
        int i = no.uib.cipr.matrix.sparse.Arrays.binarySearch(rowIndex, row,
                columnPointer[column], columnPointer[column + 1]);

        if (i >= 0 && rowIndex[i] == row)
            return i;
        else
            throw new IndexOutOfBoundsException("Entry (" + (row + 1) + ", "
                    + (column + 1) + ") is not in the matrix structure");
    }
655033
@Nullable
    TObj get(int row, int column) {
        SparseArrayCompat<TObj> array = mData.get(row);
        return array == null ? null : array.get(column);
    }
433869
public static List<Object> readRow(Row row, CellEditor cellEditor) {
		if (null == row) {
			return new ArrayList<>(0);
		}
		final short length = row.getLastCellNum();
		if (length < 0) {
			return new ArrayList<>(0);
		}
		final List<Object> cellValues = new ArrayList<>((int) length);
		Object cellValue;
		boolean isAllNull = true;
		for (short i = 0; i < length; i++) {
			cellValue = CellUtil.getCellValue(row.getCell(i), cellEditor);
			isAllNull &= StrUtil.isEmptyIfStr(cellValue);
			cellValues.add(cellValue);
		}

		if (isAllNull) {
			// 如果每个元素都为空，则定义为空行
			return new ArrayList<>(0);
		}
		return cellValues;
	}
992847
def _GetRow(self, columns=None):
        """"""

        row = self._table[self._row_index]
        if columns:
            result = []
            for col in columns:
                if col not in self.header:
                    raise TableError("Column header %s not known in table." % col)
                result.append(row[self.header.index(col)])
            row = result
        return row
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);
			}
		}

	}
1077405
public Object getValueAt(int row, int col) {

        if (row >= rows.size()) {
            return null;
        }

        Object[] colArray = (Object[]) rows.elementAt(row);

        if (col >= colArray.length) {
            return null;
        }

        return colArray[col];
    }
1162665
public float getValueAtAsFloat(final int row, final int col) {
		final Object valueAt = getValueAt(row, col);
		float number = 0;
		if (valueAt != null && !valueAt.toString().equals("")) {
			number = Float.parseFloat(valueAt.toString().trim());
		}
		return number;
	}
649038
public double[] getRow(int row) {
        checkIndices(row, 0);
        AtomicVector rowEntry = getRow(row, -1, false);
        return (rowEntry == null)
            ? new double[cols.get()]
            : toArray(rowEntry, cols.get());
    }