Fill an entry of the observation table.
        Args:
            row (str): The row of the observation table
            col (str): The column of the observation table
        Returns:
            None
778170
def _fill_table_entry(self, row, col):
        ""
        self.observation_table[row, col] = self._membership_query(row + col)
1045337
def add_row(self, row):

        """"""

        if self._field_names and len(row) != len(self._field_names):
            raise Exception("Row has incorrect number of values, (actual) %d!=%d (expected)" %(len(row),len(self._field_names)))
        if not self._field_names:
            self.field_names = [("Field %d" % (n+1)) for n in range(0,len(row))]
        self._rows.append(list(row))
348539
def append(self, row=None):
        
        self.table.append(self._normalize_row(row))
        return self.table[-1]
649801
def _insert_row(self, i, index):
        
        if i == len(self._index):
            self._add_row(index)
        else:
            self._index.insert(i, index)
            self._data.insert(i, None)
1228206
def _insert_row(self, i, index):
        
        if i == len(self._index):
            self._add_row(index)
        else:
            self._index.insert(i, index)
            for c in range(len(self._columns)):
                self._data[c].insert(i, None)
423773
def add_entry(self, row):
        
        var_call = VCFEntry(self.individuals)
        var_call.parse_entry( row )
        self.entries[(var_call.chrom, var_call.pos)] = var_call
        return var_call
939549
function Row(columnSpecs, row) {
  var i, col, type, val, cols = [];
  for (i = 0; i < columnSpecs.length; i++) {
    col = columnSpecs[i];
    type = types.fromType(col.type);
    if (col.subtype) {
      type = type(col.subtype);
    } else if (col.keytype) {
      type = type(col.keytype, col.valuetype);
    }
    val = type.deserialize(row[i]);
    this[col.name] = val;
    cols.push(val);
  }
  Object.defineProperty(this, 'columns', {
    value: cols,
    enumerable: false
  });
}
654667
public void setRow(int row, double[] columns) {
        checkIndices(row, columns.length - 1);

        if (cols <= columns.length)
            cols = columns.length;
        
        SparseDoubleVector rowVec = updateRow(row);

        for (int col = 0; col < cols; ++col) {
            double val = columns[col];
            rowVec.set(col, val);
        }
    }
422352
def <<(row)
      if row == Border::SEPARATOR
        separators << columns_size - (header ? 0 : 2)
      else
        rows_copy = rows.dup
        assert_row_sizes rows_copy << row
        rows << to_row(row)
      end
      self
    end
516901
def get_value_by_row_col(self, row, col):
        
        if row < 0 or row >= self.nRows or col < 0 or col >= self.nCols:
            raise ValueError("The row or col must be >=0 and less than "
                             "nRows (%d) or nCols (%d)!" % (self.nRows, self.nCols))
        else:
            value = self.data[int(round(row))][int(round(col))]
            if value == self.noDataValue:
                return None
            else:
                return value
654058
def add(self, col: str, value):
        
        try:
            self.df[col] = value
        except Exception as e:
            self.err(e, self.add, "Can not add column")
889743
def _add_dict_row(self, feature_dict, key=None):
        
        self._update_internal_column_state(set(feature_dict.keys()))

        # reset the row memoization
        self._row_memo = {}

        if key is not None:
            if key in self._row_name_idx:
                self._rows[self._row_name_idx[key]] = feature_dict
                return
            else:
                self._row_name_idx[key] = len(self._rows)
                self._row_name_list.append(key)

        self._rows.append(feature_dict)
921182
def get_subplot_at(self, row, column):
        
        idx = row * self.columns + column
        return self.subplots[idx]
884237
def __find_star_in_row(self, row):
        
        col = -1
        for j in range(self.n):
            if self.marked[row][j] == 1:
                col = j
                break

        return col
427588
def insert_rows(self, row, no_rows=1):
        

        # Mark content as changed
        post_command_event(self.main_window, self.ContentChangedMsg)

        tab = self.grid.current_table

        self.code_array.insert(row, no_rows, axis=0, tab=tab)
414052
def add_cell(self, row="unknown", col="unknown",
                 val="unknown", type="int32", meta=""):
        
        if self.arr is None:
            self.arr = np.array(
                [(row, val)], dtype=[ (self.name, "S50"), (col, type)])
            self.meta = np.array(
                [(row, val)], dtype=[ (self.name, TYPE_META), (col, type)])
            self.irt[row] = 0

        if not row in self._get_row_hdrs():
            self._expand_row(row)

        if not col in self._get_col_hdrs():
            self._expand_col(col, type)

        try:
            self._add_cell(val, row, col, meta)
        except ValueError:
            logging.error("unable to add val %s to [%s,%s]: "
                          "not a compatible data type" % (val, row, col))
            return False

        return True
1318787
private void checkIndices(int row, int col) {
        if (row < 0 || row >= rows)
            throw new ArrayIndexOutOfBoundsException("row: " + row);
        else if (col < 0 || col >= cols)
            throw new ArrayIndexOutOfBoundsException("column: " + col);
    }