Add another DataFrame to the PStatCounter.
429143
def merge(self, frame):
        
        for column, values in frame.iteritems():
            # Temporary hack, fix later
            counter = self._counters.get(column)
            for value in values:
                if counter is not None:
                    counter.merge(value)
404189
def merge_stats(self, other_col_counters):
        
        for column_name, _ in self._column_stats.items():
            self._column_stats[column_name] = self._column_stats[column_name] \
                .mergeStats(other_col_counters._column_stats[column_name])
        return self
896300
def sum(self, other):
        """"""
        return TimeSeries.merge(
            [self, other], operation=operations.ignorant_sum
        )
192285
def addDataset(self, dataset):
        
        self._datasets.append(dataset)
        self._dataChanged = True
        self._addDatasetAction(dataset)
452836
protected void addToStatistics(ClusteringFeature other) {
    n += other.n;
    VMath.plusEquals(ls, other.ls);
    ss += other.ss;
  }
204183
def dataframe(self):
        
        frames = []
        for game in self.__iter__():
            # If both the runs scored and allowed are None, the game hasn't
            # been played yet, and the data should not be included in the
            # DataFrame.
            if game._runs_scored is None and game._runs_allowed is None:
                continue
            frames.append(game.dataframe)
        if frames == []:
            return None
        return pd.concat(frames)
151877
def main(self):
        
        self.dataframe_setup()
        self.figure_populate(self.outputfolder,
                             self.image_report,
                             self.header_list,
                             self.samples,
                             'genesippr',
                             'report',
                             fail=self.fail)
538119
def stats(self, columns):
        
        def reduce_func(sc1, sc2):
            return sc1.merge_pstats(sc2)

        return self._rdd.mapPartitions(lambda partition: [
            PStatCounter(dataframes=partition, columns=columns)])\
            .reduce(reduce_func)
218483
def add(self, datapoint):
        
        if not self.is_full:
            self.set_datapoint(self.cur_index, datapoint)
            self.cur_index += 1
303772
def add(self, name, *vals):
        '''
        
        '''
        item = self.frames[-1].get(name)
        if item is None:
            self.frames[-1][name] = item = []
        item.extend(vals)
572881
function addCounts(o1, o2) {
  var result;
  if (o1 && o2) {
    result = _.merge(o1, o2, function (a, b) {
      return a + b;
    });
  }
  else if (o1) {
    result = o1;
  }
  else {
    result = o2;
  }
  return result;
}
932626
def add_data(self, data):  # add append option later
        
        df = pd.DataFrame(data)
        name, dtype = self.get_singular_and_plural_dtype(self.dtype)
        if name in df.columns:
            df.index = df[name]
        df.index.name = name + " name"
        self.df = df
390093
public DataPoint add(DataPoint another) {
        if (type == Type.NONE) {
            _cloneFrom(another);
        } else {
            if (another.type != Type.NONE) {
                add(another.value());
            }
        }

        return this;
    }
1224840
def count(self, stats, value, sample_rate=1):
        
        self.update_stats(stats, value, self.SC_COUNT, sample_rate)
789783
def append(self, other):
        
        if not isinstance(other,StarPopulation):
            raise TypeError('Only StarPopulation objects can be appended to a StarPopulation.')
        if not np.all(self.stars.columns == other.stars.columns):
            raise ValueError('Two populations must have same columns to combine them.')

        if len(self.constraints) > 0:
            logging.warning('All constraints are cleared when appending another population.')

        self.stars = pd.concat((self.stars, other.stars))

        if self.orbpop is not None and other.orbpop is not None:
            self.orbpop = self.orbpop + other.orbpop
411330
private void updateStatistics() {
        final PNCounterService service = getService();
        final LocalPNCounterStatsImpl stats = service.getLocalPNCounterStats(name);
        if (delta > 0) {
            stats.incrementIncrementOperationCount();
        } else if (delta < 0) {
            stats.incrementDecrementOperationCount();
        }
        stats.setValue(getBeforeUpdate ? (response.getValue() + delta) : response.getValue());
    }
1061833
def add(self, v):
        ""
        self.population.append(v)
        self._current_popsize += 1
        v.position = len(self._hist)
        self._hist.append(v)
        self.bsf = v
        self.estopping = v
        self._density += self.get_density(v)