Combines the state of another {@code IntSummaryStatistics} into this one.

@param other another {@code IntSummaryStatistics}
@throws NullPointerException if {@code other} is null
13518
public void combine(IntSummaryStatistics other) {
        count += other.count;
        sum += other.sum;
        min = Math.min(min, other.min);
        max = Math.max(max, other.max);
    }
1321854
public void putAll(FlexiBean other) {
        if (other.size() > 0) {
            if (data == Collections.EMPTY_MAP) {
                data = new LinkedHashMap<>(other.data);
            } else {
                data.putAll(other.data);
            }
        }
    }
14020
private List<StatValueAO> mergeStatValues(List<StatValueAO> firstStat, List<StatValueAO> secondStat) {
        // If stats are null or not of the same type return nothing
        if (firstStat == null || secondStat == null) {
            return new ArrayList<>();
        }

        List<StatValueAO> result = new ArrayList<>();
        for (StatValueAO firstStatValue : firstStat) {
            for (StatValueAO secondStatValue : secondStat) {
                // If it's one stat value type cumulate them
                if (firstStatValue.getName().equals(secondStatValue.getName())) {
                    try {
                        // Stat value equals NoR, just set it
                        if ("NoR".equals(firstStatValue.getValue()) || "NoR".equals(secondStatValue.getValue())) {
                            final StatValueAO norValue = new LongValueAO(firstStatValue.getName(), Long.MAX_VALUE);
                            result.add(norValue);
                        } else if (firstStatValue instanceof LongValueAO && secondStatValue instanceof LongValueAO) {
                            Number firstStatNumber = NumberFormat.getNumberInstance(Locale.US).parse(firstStatValue.getValue());
                            Number secondStatNumber = NumberFormat.getNumberInstance(Locale.US).parse(secondStatValue.getValue());
                            final StatValueAO sumValue = new LongValueAO(firstStatValue.getName(), firstStatNumber.longValue() + secondStatNumber.longValue());

                            result.add(sumValue);
                        } else if (firstStatValue instanceof DoubleValueAO && secondStatValue instanceof DoubleValueAO) {
                            Number firstStatNumber = NumberFormat.getNumberInstance(Locale.US).parse(firstStatValue.getValue());
                            Number secondStatNumber = NumberFormat.getNumberInstance(Locale.US).parse(secondStatValue.getValue());
                            final StatValueAO sumValue = new DoubleValueAO(firstStatValue.getName(), firstStatNumber.doubleValue() + secondStatNumber.doubleValue());

                            result.add(sumValue);
                        }
                    }
                    catch (ParseException ex) {
                        LOGGER.warn("Can't parse stat values: " + firstStatValue.getValue() + " and " + secondStatValue.getValue());
                    }
                }
            }
        }

        return result;
    }
752754
@Override
    public void copyFrom(Frame<IsNullValue> other) {
        super.copyFrom(other);
        decision = ((IsNullValueFrame) other).decision;
        if (trackValueNumbers) {
            knownValueMap = Util.makeSmallHashMap(((IsNullValueFrame) other).knownValueMap);
        }
    }
1019401
public void add(IntFloatVector other) {
        if (other instanceof IntFloatUnsortedVector) {
            IntFloatUnsortedVector vec = (IntFloatUnsortedVector) other;
            for (int i=0; i<vec.top; i++) {
                this.add(vec.idx[i], vec.vals[i]);
            }
        } else {
            //  TODO: Add special case for IntFloatDenseVector.
            other.iterate(new SparseBinaryOpApplier(this, new Lambda.FloatAdd()));
        }
    }
852354
@Override
    public void merge(InternalEventPipeline other) {
        InternalEventPipeline pipeline = currentPipeline.get();
        if (pipeline == null) {
            fallback.merge(other);
            return;
        }
        pipeline.merge(other);
    }
80469
public void elemAdd(VTensor other) {
        checkEqualSize(this, other);
        for (int c = 0; c < this.size(); c++) {
            addValue(c, other.getValue(c));
        }
    }
1023947
@Override
  public void put(Mean other) {
    if(!(other instanceof MeanVariance)) {
      throw new IllegalArgumentException("I cannot combine Mean and MeanVariance to a MeanVariance.");
    }
    final MeanVariance mvo = (MeanVariance) other;
    final double on = mvo.n, osum = mvo.sum;
    final double tmp = n * osum - sum * on;
    final double oldn = n; // tmp copy
    n += on;
    sum += osum;
    m2 += mvo.m2 + tmp * tmp / (on * n * oldn);
  }
465540
public void set(LongIntSortedVector other) {
        this.used = other.used;
        this.indices = LongArrays.copyOf(other.indices);
        this.values = IntArrays.copyOf(other.values);
    }
523681
public void combine(SpdStat other) {
        if (other == null)
            return;
        if (stat.isEnabled() && other.isEnabled())
            //stat.combine((TimeStatisticImpl)other.getStatistic());
            stat.combine(other.getStatistic());
    }
653691
public void add(MultidimensionalReward other) {
        for (Map.Entry<Integer, Float> entry : other.map.entrySet()) {
            Integer dimension = entry.getKey();
            Float reward_value = entry.getValue();
            this.add(dimension.intValue(), reward_value.floatValue());
        }
    }
1365801
public void tally( Statistics other )
    {
        rightCount += other.rightCount();
        wrongCount += other.wrongCount();
        ignoredCount += other.ignoredCount();
        exceptionCount += other.exceptionCount();
    }
1136211
public void merge(final TagRequirements other) {
        if (other != null) {
            matchAllOf.addAll(other.matchAllOf);
            matchOneOf.addAll(other.matchOneOf);
        }
    }
189778
private void merge(ExecutionStatistics otherStatistics) {
        for (String s : otherStatistics.executionInfo.keySet())
        {
            TimingData thisStats = this.executionInfo.get(s);
            TimingData otherStats = otherStatistics.executionInfo.get(s);
            if(thisStats == null) {
                this.executionInfo.put(s,otherStats);
            } else {
                thisStats.merge(otherStats);
            }

        }
    }
1007729
@Override
    public void merge(Evaluation other) {
        if (other == null)
            return;

        truePositives.incrementAll(other.truePositives);
        falsePositives.incrementAll(other.falsePositives);
        trueNegatives.incrementAll(other.trueNegatives);
        falseNegatives.incrementAll(other.falseNegatives);

        if (confusion == null) {
            if (other.confusion != null)
                confusion = new ConfusionMatrix<>(other.confusion);
        } else {
            if (other.confusion != null)
                confusion().add(other.confusion);
        }
        numRowCounter += other.numRowCounter;
        if (labelsList.isEmpty())
            labelsList.addAll(other.labelsList);

        if (topN != other.topN) {
            log.warn("Different topN values ({} vs {}) detected during Evaluation merging. Top N accuracy may not be accurate.",
                            topN, other.topN);
        }
        this.topNCorrectCount += other.topNCorrectCount;
        this.topNTotalCount += other.topNTotalCount;
    }
863075
def merge(self, other):
        
        self.stats = set(self.stats)
        self.stats.update(set(other.stats))
        self.stats = list(self.stats)
        if other._error:
            self._error = True
668502
public Tags merge(Tags other) {
    // Dereference "other" first as a null pointer check so we cannot risk returning null later.
    if (other.isEmpty()) {
      return this;
    }
    if (this.isEmpty()) {
      return other;
    }
    SortedMap<String, SortedSet<Object>> merged = new TreeMap<String, SortedSet<Object>>();
    for (Map.Entry<String, SortedSet<Object>> e : map.entrySet()) {
      SortedSet<Object> otherValues = other.map.get(e.getKey());
      if (otherValues == null || e.getValue().containsAll(otherValues)) {
        // Our values are a superset of the values in the other map, so just use them.
        merged.put(e.getKey(), e.getValue());
      } else if (otherValues.containsAll(e.getValue())) {
        // The other map's values are a superset of ours, so just use them.
        merged.put(e.getKey(), otherValues);
      } else {
        // Values exist in both maps and neither is a superset, so we really must merge.
        SortedSet<Object> mergedValues = new TreeSet<Object>(e.getValue());
        mergedValues.addAll(otherValues);
        merged.put(e.getKey(), Collections.unmodifiableSortedSet(mergedValues));
      }
    }
    for (Map.Entry<String, SortedSet<Object>> e : other.map.entrySet()) {
      // Finally add those values that were only in the other map.
      if (!map.containsKey(e.getKey())) {
        merged.put(e.getKey(), e.getValue());
      }
    }
    return new Tags(Collections.unmodifiableSortedMap(merged));
  }