Returns unique values in a column
962991
def unique_(self, col):
        
        try:
            df = self.df.drop_duplicates(subset=[col], inplace=False)
            return list(df[col])
        except Exception as e:
            self.err(e, "Can not select unique data")
1217540
function unique( field ) {
   const seen = {};
   const id = field ? value => value[ field ] : value => value;

   return value => {
      const key = id( value );
      if( seen[ key ] ) {
         return false;
      }
      seen[ key ] = true;
      return true;
   };
}
826848
function uniqueStrings(input){
	const output = {};
	for(let i = 0, l = input.length; i < l; ++i)
		output[input[i]] = true;
	return Object.keys(output);
}
557548
def get_unique_match(table, colname, value):
    
    # FIXME, This is here for python 3.5, where astropy is now returning bytes
    # instead of str
    if table[colname].dtype.kind in ['S', 'U']:
        mask = table[colname].astype(str) == value
    else:
        mask = table[colname] == value

    if mask.sum() != 1:
        raise KeyError("%i rows in column %s match value %s" %
                       (mask.sum(), colname, value))
    return np.argmax(mask)
978933
def get_uniques(l):
    
    result = []

    for i in l:
        if i not in result:
            result.append(i)

    return result
945889
def uniquecols(df):
    
    bool_idx = df.apply(lambda col: len(np.unique(col)) == 1, axis=0)
    df = df.loc[:, bool_idx].iloc[0:1, :].reset_index(drop=True)
    return df
723077
def unique(series: pd.Series) -> pd.Series:
    """"""
    return ~series.duplicated(keep=False)
1056740
function unique(cells) {
  if(cells.length === 0) {
    return []
  }
  var ptr = 1
    , len = cells.length
  for(var i=1; i<len; ++i) {
    var a = cells[i]
    if(compareCells(a, cells[i-1])) {
      if(i === ptr) {
        ptr++
        continue
      }
      cells[ptr++] = a
    }
  }
  cells.length = ptr
  return cells
}
421600
function unique(array) {
    "use strict";
    var o = {},
        r = [];
    for (var i = 0, len = array.length; i !== len; i++) {
        var d = array[i];
        if (typeof o[d] === "undefined") {
            o[d] = 1;
            r[r.length] = d;
        }
    }
    return r;
}
308987
def select_distinct(self, table, cols='*', execute=True):
        """"""
        return self.select(table, cols, execute, select_type='SELECT DISTINCT')
65570
function unique(array) {
  const results = [];

  for (let idx = 0, len = array.length; idx < len; idx++) {
    if (!contains(results, array[idx])) {
      results.push(array[idx]);
    }
  }

  return results;
}
1218106
def unique(self, values):
        """"""
        _, count = self.count()
        if not np.array_equiv(count, 1):
            raise ValueError("Not every entry in the table is assigned a unique value")
        return self.sum(values)
1360015
def distinct_value_fractions(self):
        
        return pd.DataFrame([c.dcount() / float(self.size()) for c in self.columns()],
                            index=[c.name() for c in self.columns()], columns=["fraction"])
684627
function uniqueValues(categorical) {
  const countMap = {};
  categorical.forEach((val) => {
    if (!(val in countMap)) {
      countMap[val] = 0;
    }
    countMap[val] += 1;
  });
  const uniques = [];
  const counts = [];
  Object.keys(countMap).forEach((uniqueVal) => {
    uniques.push(uniqueVal);
    counts.push(countMap[uniqueVal]);
  });
  return [uniques, counts];
}
638194
def unique_float(data,
                 return_index=False,
                 return_inverse=False,
                 digits=None):
    
    data = np.asanyarray(data)
    as_int = float_to_int(data, digits)
    _junk, unique, inverse = np.unique(as_int,
                                       return_index=True,
                                       return_inverse=True)

    if (not return_index) and (not return_inverse):
        return data[unique]

    result = [data[unique]]

    if return_index:
        result.append(unique)
    if return_inverse:
        result.append(inverse)
    return tuple(result)
965015
public function getColumns()
    {
        $columns = array();
        foreach ($this->getRows() as $row) {
            $columns = array_merge($columns, $row->getColumns());
        }
        return array_unique($columns);
    }
889016
def unique_otuids(groups):
    
    uniques = {key: set() for key in groups}
    for i, group in enumerate(groups):
        to_combine = groups.values()[:i]+groups.values()[i+1:]
        combined = combine_sets(*to_combine)
        uniques[group] = groups[group].difference(combined)
    return uniques