Merge the min/max value from another instance into this one.
@param another   another instance of MinMaxHolder
190663
@Override
	public void merge(MinMaxHolder another){
		Long anotherMin = another.getMaxAsLong();
		if (anotherMin != null){
			evaluate(anotherMin);
		}
		Long anotherMax = another.getMaxAsLong();
		if (anotherMax != null){
			evaluate(anotherMax);
		}
	}
297657
public void union(GeneralSubtrees other) {
        if (other != null) {
            for (int i = 0, n = other.size(); i < n; i++) {
                add(other.get(i));
            }
            // Minimize this
            minimize();
        }
    }
744107
public void merge(CandidateCluster other) {
        indices.addAll(other.indices);
        VectorMath.add(sumVector, other.sumVector);
        centroid = null;
    }
1156857
private static void mergeReversed(List<String> merged,
	                                  final List<String> other) {

		if(other.isEmpty())
			return;

		if(merged.isEmpty()) {
			merged.addAll(other);
			return;
		}

		ListIterator<String> m = merged.listIterator();
		ListIterator<String> o = other.listIterator();

		String nextM, prevO;
		prevO = o.next();
		while(m.hasNext()) {
			// peek at m
			nextM = m.next();
			m.previous();

			//insert from O until exhausted or occurs after nextM
			while(prevO.compareTo(nextM) > 0) {
				m.add(prevO);
				if(!o.hasNext()) {
					return;
				}
				prevO = o.next();
			}
			//remove duplicates
			if(prevO.equals(nextM)) {
				if(!o.hasNext()) {
					return;
				}
				prevO = o.next();
			}

			m.next();
		}
		m.add(prevO);
		while(o.hasNext()) {
			m.add(o.next());
		}

	}
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);
            }
        }
    }
1256407
public Bbox union(Bbox other) {
		if (other.getWidth() == 0 && other.getHeight() == 0 && other.getX() == 0 && other.getY() == 0) {
			return (Bbox) clone();
		}
		if (width == 0 && height == 0 && x == 0 && y == 0) {
			return (Bbox) other.clone();
		}

		double minx = other.getX() < this.getX() ? other.getX() : this.getX();
		double maxx = other.getEndPoint().getX() > this.getEndPoint().getX() ? other.getEndPoint().getX() : this
				.getEndPoint().getX();
		double miny = other.getY() < this.getY() ? other.getY() : this.getY();
		double maxy = other.getEndPoint().getY() > this.getEndPoint().getY() ? other.getEndPoint().getY() : this
				.getEndPoint().getY();
		return new Bbox(minx, miny, (maxx - minx), (maxy - miny));
	}
266236
def merge(self, other):
        
        for this, other in zip(self.stats, other.stats):
            this.merge(other)
1176570
def MergeFrom(self, other):
    
    self._values.extend(other._values)
    self._message_listener.Modified()
58817
public void add(ScalableStatistics other) {
    count += other.count;
    min = Math.min(min, other.min);
    max = Math.max(max, other.max);
    sum += other.sum;
    sumOfSquares += other.sumOfSquares;
    tdigest.add(other.tdigest);
    if (other.exactValues != null) {
      for (int i = 0; i < other.numExactValues; i++) {
        addQuantileValue(other.exactValues[i]);
      }
    }
  }
125210
public static void merge(List<PathDetail> pathDetails, List<PathDetail> otherDetails) {
        // Make sure that the PathDetail list is merged correctly at via points
        if (!pathDetails.isEmpty() && !otherDetails.isEmpty()) {
            PathDetail lastDetail = pathDetails.get(pathDetails.size() - 1);
            if (lastDetail.getValue().equals(otherDetails.get(0).getValue())) {
                lastDetail.setLast(otherDetails.get(0).getLast());
                otherDetails.remove(0);
            }
        }

        pathDetails.addAll(otherDetails);
    }
683114
public void combine(SimpleItem other)
    {
        for (Map.Entry<String, Integer> entry : other.labelMap.entrySet())
        {
            addLabel(entry.getKey(), entry.getValue());
        }
    }
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;
    }
1074823
@Override
    public void merge(ROC other) {
        if (this.thresholdSteps != other.thresholdSteps) {
            throw new UnsupportedOperationException(
                    "Cannot merge ROC instances with different numbers of threshold steps ("
                            + this.thresholdSteps + " vs. " + other.thresholdSteps + ")");
        }
        this.countActualPositive += other.countActualPositive;
        this.countActualNegative += other.countActualNegative;
        this.auc = null;
        this.auprc = null;
        this.rocCurve = null;
        this.prCurve = null;


        if (isExact) {
            if (other.exampleCount == 0) {
                return;
            }

            if (this.exampleCount == 0) {
                this.exampleCount = other.exampleCount;
                this.probAndLabel = other.probAndLabel;
                return;
            }

            if (this.exampleCount + other.exampleCount > this.probAndLabel.size(0)) {
                //Allocate new array
                val newSize = this.probAndLabel.size(0) + Math.max(other.probAndLabel.size(0), exactAllocBlockSize);
                INDArray newProbAndLabel = Nd4j.create(DataType.DOUBLE, newSize, 2);
                newProbAndLabel.put(new INDArrayIndex[]{interval(0, exampleCount), all()}, probAndLabel.get(interval(0, exampleCount), all()));
                probAndLabel = newProbAndLabel;
            }

            INDArray toPut = other.probAndLabel.get(interval(0, other.exampleCount), all());
            probAndLabel.put(new INDArrayIndex[]{
                            interval(exampleCount, exampleCount + other.exampleCount), all()},
                    toPut);
        } else {
            for (Double d : this.counts.keySet()) {
                CountsForThreshold cft = this.counts.get(d);
                CountsForThreshold otherCft = other.counts.get(d);
                cft.countTruePositive += otherCft.countTruePositive;
                cft.countFalsePositive += otherCft.countFalsePositive;
            }
        }

        this.exampleCount += other.exampleCount;
    }
1336581
private void merge(LinkedPair closestPair) {


		int first = closestPair.getFirst();
		int second = closestPair.getSecond();

		for (int other=0;other<numItems;other++) {
			matrix[Math.min(first,other)][Math.max(first, other)] = link(getDistance(first, other), getDistance(second, other));
		}

	}
506783
private void updateMinMax() {
    if(values.length == 0) {
      return; // Keep invalid.
    }
    min = max = values[0];
    for(int i = 1; i < values.length; i++) {
      int v = values[i];
      min = min < v ? min : v;
      max = max > v ? max : v;
    }
  }
136627
public boolean merge(AbstractTransition another) {
        if (!isCompatible(another)) {
            return false;
        }
        if (another.mId != null) {
            if (mId == null) {
                mId = another.mId;
            } else {
                StringBuilder sb = new StringBuilder(mId.length() + another.mId.length());
                sb.append(mId);
                sb.append("_MERGED_");
                sb.append(another.mId);
                mId = sb.toString();
            }
        }
        mUpdateStateAfterUpdateProgress |= another.mUpdateStateAfterUpdateProgress;
        mSetupList.addAll(another.mSetupList);
        Collections.sort(mSetupList, new Comparator<S>() {
            @Override
            public int compare(S lhs, S rhs) {
                if (lhs instanceof AbstractTransitionBuilder && rhs instanceof AbstractTransitionBuilder) {
                    AbstractTransitionBuilder left = (AbstractTransitionBuilder) lhs;
                    AbstractTransitionBuilder right = (AbstractTransitionBuilder) rhs;
                    float startLeft = left.mReverse ? left.mEnd : left.mStart;
                    float startRight = right.mReverse ? right.mEnd : right.mStart;
                    return (int) ((startRight - startLeft) * 1000);
                }
                return 0;
            }
        });

        return true;
    }
382358
function(other) {
      if (!other) {
        return;
      }
      
      // This does the inverse of _mergeMagicFields.
      this.id = other.id;
      this.createdAt = other.createdAt;
      this.updatedAt = other.updatedAt;

      this._copyServerData(other._serverData);

      this._hasData = true;
    }